{"version":3,"file":"js/623.dd06db4d.js","mappings":"siBACA,SAAgB,KAAO,2BAA2B,eAAe,mCAAmC,gBAAgB,oCAAoC,mBAAmB,uCAAuC,sBAAsB,0CAA0C,0BAA0B,8CAA8C,yBAAyB,6CAA6C,2BAA2B,+CAA+C,qBAAqB,yCAAyC,wBAAwB,4CAA4C,uBAAuB,2CAA2C,uBAAuB,2CAA2C,sBAAsB,0CAA0C,oBAAoB,wCAAwC,oBAAoB,wCAAwC,kBAAkB,sCAAsC,oBAAoB,wCAAwC,mBAAmB,uCAAuC,oBAAoB,wCAAwC,sBAAsB,0CAA0C,qBAAqB,yCAAyC,wBAAwB,4CAA4C,mBAAmB,uCAAuC,yBAAyB,6CAA6C,mBAAmB,uCAAuC,kBAAkB,sCAAsC,mBAAmB,uCAAuC,qBAAqB,yCAAyC,uBAAuB,2CAA2C,sBAAsB,0CAA0C,6BAA6B,iDAAiD,kBAAkB,sCAAsC,mBAAmB,uCAAuC,0BAA0B,8CAA8C,qBAAqB,yCAAyC,4BAA4B,gDAAgD,qBAAqB,yCAAyC,2BAA2B,+CAA+C,2BAA2B,+CAA+C,4BAA4B,gDAAgD,cAAc,kCAAkC,iBAAiB,qCAAqC,YAAY,gCAAgC,kBAAkB,sCAAsC,mBAAmB,uCAAuC,eAAe,mCAAmC,qBAAqB,yCAAyC,sBAAsB,0CAA0C,WAAW,+BAA+B,SAAW,+BAA+B,sBAAsB,0CAA0C,QAAU,8BAA8B,SAAW,gCCiD9lGA,EAAOC,EAAAA,YACnB,EAEEC,QAAAA,EACAC,SAAAA,EACAC,UAAAA,EACAC,OAAAA,EACAC,UAAAA,EACAC,SAAAA,EACAC,MAAAA,EACAC,QAAAA,EACAC,UAAAA,EACAC,OAAAA,EACAC,OAAAA,EACAC,MAAAA,EACAC,UAAAA,EACAC,UAAAA,KACGC,GAEJC,KAEA,MAAMC,GAAaC,EAAAA,EAAAA,GAAK,CACvBC,EAAOC,KACPN,EACAb,GAAWkB,EAAO,QAClBf,GAAUe,EAAO,eACjBjB,GAAYiB,EAAO,uBACnBhB,GAAagB,EAAO,mBACnBd,GAAac,EAAO,YACrBb,GAAYa,EAAO,SACnBX,GAAWW,EAAO,gBAAgBX,KAClCC,GAAaU,EAAO,cAAcV,KAClCG,GAASO,EAAO,cAAcP,KAC9BC,GAAaM,EAAO,kBAAkBN,KACtCH,GAAUS,EAAO,eAAeT,KAChCH,GAASY,EAAO,cAAcZ,KAC9BQ,EAAMM,SAAWF,EAAO,uBACxBR,GAAUQ,EAAO,UAAUR,OAG5B,OACCX,EAAAA,cAACsB,EAAAA,GAAA,CAAYN,IAAKA,KAASD,EAAOD,UAAWG,GAC3CF,EAAMQ,SACR,IAIHxB,EAAKyB,YAAc,M,ogHCtFnB,MAAMC,EAAiB,CAAC,EAwOjB,IA2qWKC,EA5DAC,EA1FAC,EAr3EAC,EAtYAC,EAljBAC,EA1yKAC,EAprCAC,EA9kBAC,EAxSAC,EAlHAC,EA7KAC,EArHAC,EAuhFAC,EA7+CAC,EApuBAC,EAtUAH,IAAAA,EAAAA,GAAA,IACVI,YAAc,eACdJ,EAAAK,KAAO,OACPL,EAAAM,eAAiB,iBAHPN,GAqHAD,IAAAA,EAAAA,GAAA,IAEVQ,KAAO,OAEPR,EAAAS,QAAU,UAJAT,GA6KAD,IAAAA,EAAAA,GAAA,IACVW,KAAO,OACPX,EAAAY,gBAAkB,mBAClBZ,EAAAa,IAAM,MACNb,EAAAc,eAAiB,kBACjBd,EAAAe,IAAM,MACNf,EAAAgB,eAAiB,kBACjBhB,EAAAiB,kBAAoB,qBAPVjB,GAoCAK,IAAAA,EAAAA,GAAA,IACVa,iBAAmB,oBACnBb,EAAAc,KAAO,OACPd,EAAAe,SAAW,WACXf,EAAAgB,QAAU,UACVhB,EAAAiB,UAAY,YACZjB,EAAAkB,UAAY,YANFlB,GASAmB,EAAAA,CAAAA,IACVA,EAAAN,iBAAmB,oBACnBM,EAAAL,KAAO,OACPK,EAAAJ,SAAW,WACXI,EAAAH,QAAU,UACVG,EAAAF,UAAY,YACZE,EAAAD,UAAY,YANFC,GAAAA,CAAAA,GAAA,IAqEAzB,IAAAA,EAAAA,GAAA,IACV0B,cAAgB,kBAChB1B,EAAA2B,mBAAqB,sBACrB3B,EAAA4B,cAAgB,iBAChB5B,EAAA6B,cAAgB,iBAChB7B,EAAA8B,gBAAkB,mBAClB9B,EAAA+B,mBAAqB,uBACrB/B,EAAAgC,oBAAsB,uBACtBhC,EAAAiC,eAAiB,kBACjBjC,EAAAkC,kBAAoB,sBACpBlC,EAAAmC,qBAAuB,0BACvBnC,EAAAoC,qBAAuB,0BACvBpC,EAAAqC,oBAAsB,yBACtBrC,EAAAsC,uBAAyB,4BACzBtC,EAAAuC,YAAc,eACdvC,EAAAwC,eAAiB,mBACjBxC,EAAAyC,0BAA4B,8BAC5BzC,EAAA0C,mBAAqB,uBACrB1C,EAAA2C,eAAiB,mBACjB3C,EAAA4C,mBAAqB,uBACrB5C,EAAA6C,UAAY,aACZ7C,EAAA8C,aAAe,iBACf9C,EAAA+C,wBAA0B,4BAC1B/C,EAAAgD,iBAAmB,qBACnBhD,EAAAiD,aAAe,iBACfjD,EAAAkD,iBAAmB,qBACnBlD,EAAAmD,SAAW,YACXnD,EAAAoD,YAAc,gBACdpD,EAAAqD,uBAAyB,0BACzBrD,EAAAsD,iBAAmB,oBACnBtD,EAAAuD,8BAAgC,kCAChCvD,EAAAwD,uBAAyB,2BACzBxD,EAAAyD,sBAAwB,yBAhCdzD,GAwSAD,IAAAA,EAAAA,GAAA,IACV2D,sBAAwB,0BACxB3D,EAAA4D,iBAAmB,qBACnB5D,EAAA6D,mBAAqB,uBACrB7D,EAAA8D,iCAAmC,uCACnC9D,EAAA+D,8BAAgC,oCAChC/D,EAAAgE,sBAAwB,0BACxBhE,EAAAiE,wBAA0B,4BAC1BjE,EAAAkE,mBAAqB,uBACrBlE,EAAAmE,kBAAoB,qBACpBnE,EAAAoE,mBAAqB,uBACrBpE,EAAAqE,uBAAyB,2BACzBrE,EAAAsE,qBAAuB,yBACvBtE,EAAAuE,aAAe,eACfvE,EAAAwE,UAAY,aACZxE,EAAAyE,WAAa,cACbzE,EAAA0E,mBAAqB,uBACrB1E,EAAA2E,uBAAyB,4BAjBf3E,GA8WAM,IAAAA,EAAAA,GAAA,IAEVsE,KAAO,OAEPtE,EAAAuE,OAAS,SAETvE,EAAAwE,WAAa,aAEbxE,EAAAyE,SAAW,WARDzE,GAYA0E,EAAAA,CAAAA,IAEVA,EAAAC,MAAQ,QAERD,EAAAF,WAAa,aAEbE,EAAAE,QAAU,UANAF,GAAAA,CAAAA,GAAA,IAoJAG,EAAAA,CAAAA,IACVA,EAAAC,UAAY,YACZD,EAAAE,OAAS,SACTF,EAAAG,aAAe,gBAHLH,GAAAA,CAAAA,GAAA,IAmBAI,EAAAA,CAAAA,IACVA,EAAAlE,KAAO,OACPkE,EAAAC,MAAQ,QACRD,EAAAE,OAAS,SAHCF,GAAAA,CAAAA,GAAA,IAqCAG,EAAAA,CAAAA,IAEVA,EAAAC,UAAY,aAEZD,EAAAE,cAAgB,kBAJNF,GAAAA,CAAAA,GAAA,IAQA3F,IAAAA,EAAAA,GAAA,IAEV8F,aAAe,gBAEf9F,EAAA+F,iBAAmB,oBAEnB/F,EAAAgG,gBAAkB,mBAElBhG,EAAAiG,cAAgB,iBAEhBjG,EAAAkG,QAAU,UAVAlG,GAcAmG,EAAAA,CAAAA,IAEVA,EAAAC,IAAM,MAEND,EAAAE,IAAM,MAJIF,GAAAA,CAAAA,GAAA,IAQAG,EAAAA,CAAAA,IAEVA,EAAAC,UAAY,YAEZD,EAAAE,QAAU,UAEVF,EAAAG,OAAS,SAETH,EAAAI,SAAW,WAEXJ,EAAAK,OAAS,SAVCL,GAAAA,CAAAA,GAAA,IAoQAM,EAAAA,CAAAA,IAEVA,EAAAC,UAAY,YAEZD,EAAAE,SAAW,WAEXF,EAAAG,aAAe,iBAEfH,EAAAI,WAAa,eAEbJ,EAAAK,UAAY,YAVFL,GAAAA,CAAAA,GAAA,IAyFAM,EAAAA,CAAAA,IAEVA,EAAApB,aAAe,gBAEfoB,EAAAnB,iBAAmB,oBAEnBmB,EAAAlB,gBAAkB,mBAElBkB,EAAAjB,cAAgB,iBAEhBiB,EAAAhB,QAAU,UAVAgB,GAAAA,CAAAA,GAAA,IAcAC,EAAAA,CAAAA,IAEVA,EAAAZ,UAAY,YAEZY,EAAAX,QAAU,UAEVW,EAAAV,OAAS,SAETU,EAAAT,SAAW,WAEXS,EAAAR,OAAS,SAVCQ,GAAAA,CAAAA,GAAA,IAsgBAC,EAAAA,CAAAA,IAEVA,EAAAtB,aAAe,gBAEfsB,EAAArB,iBAAmB,oBAEnBqB,EAAApB,gBAAkB,mBAElBoB,EAAAnB,cAAgB,iBAEhBmB,EAAAlB,QAAU,UAVAkB,GAAAA,CAAAA,GAAA,IAcAC,EAAAA,CAAAA,IAEVA,EAAAd,UAAY,YAEZc,EAAAb,QAAU,UAEVa,EAAAZ,OAAS,SAETY,EAAAX,SAAW,WAEXW,EAAAV,OAAS,SAVCU,GAAAA,CAAAA,GAAA,IAyQAC,EAAAA,CAAAA,IACVA,EAAAC,cAAgB,gBAChBD,EAAAE,SAAW,WACXF,EAAAG,YAAc,cACdH,EAAAI,cAAgB,gBAChBJ,EAAAK,WAAa,aACbL,EAAAM,aAAe,eACfN,EAAAO,iBAAmB,qBAPTP,GAAAA,CAAAA,GAAA,IAsBAvH,IAAAA,EAAAA,GAAA,IACV+H,IAAM,MACN/H,EAAAgI,IAAM,MACNhI,EAAAiI,GAAK,KACLjI,EAAAkI,IAAM,MACNlI,EAAAmI,IAAM,MACNnI,EAAAoI,IAAM,MACNpI,EAAAqI,IAAM,MACNrI,EAAAsI,KAAO,OACPtI,EAAAuI,MAAQ,QACRvI,EAAAwI,IAAM,MAVIxI,GAaAyI,EAAAA,CAAAA,IACVA,EAAAV,IAAM,MACNU,EAAAT,IAAM,MACNS,EAAAR,GAAK,KACLQ,EAAAP,IAAM,MACNO,EAAAN,IAAM,MACNM,EAAAL,IAAM,MACNK,EAAAJ,IAAM,MACNI,EAAAH,KAAO,OACPG,EAAAF,MAAQ,QACRE,EAAAD,IAAM,MAVIC,GAAAA,CAAAA,GAAA,IA4EAlI,IAAAA,EAAAA,GAAA,IAEVmI,GAAK,KAELnI,EAAAoI,GAAK,KAELpI,EAAAqI,GAAK,KAELrI,EAAAsI,GAAK,KAELtI,EAAAuI,GAAK,KAELvI,EAAAwI,GAAK,KAELxI,EAAAyI,GAAK,KAELzI,EAAA0I,GAAK,KAEL1I,EAAA2I,GAAK,KAEL3I,EAAA4I,GAAK,KAEL5I,EAAA6I,GAAK,KAEL7I,EAAA8I,GAAK,KAEL9I,EAAA+I,GAAK,KAEL/I,EAAAgJ,GAAK,KAELhJ,EAAAiJ,GAAK,KAELjJ,EAAAkJ,GAAK,KAELlJ,EAAAmJ,GAAK,KAELnJ,EAAAoJ,GAAK,KAELpJ,EAAAqJ,GAAK,KAELrJ,EAAAsJ,GAAK,KAELtJ,EAAAuJ,GAAK,KAELvJ,EAAAwJ,GAAK,KAELxJ,EAAAyJ,GAAK,KAELzJ,EAAA0J,GAAK,KAEL1J,EAAA2J,GAAK,KAEL3J,EAAA4J,GAAK,KAEL5J,EAAA6J,GAAK,KAEL7J,EAAA8J,GAAK,KAEL9J,EAAA+J,GAAK,KAEL/J,EAAAgK,GAAK,KAELhK,EAAAiK,GAAK,KAELjK,EAAAkK,GAAK,KAELlK,EAAAmK,GAAK,KAELnK,EAAAoK,GAAK,KAELpK,EAAAqK,GAAK,KAELrK,EAAAsK,GAAK,KAELtK,EAAAuK,GAAK,KAELvK,EAAAwK,GAAK,KAELxK,EAAAyK,GAAK,KAELzK,EAAA0K,GAAK,KAEL1K,EAAA2K,GAAK,KAEL3K,EAAA4K,GAAK,KAEL5K,EAAA6K,GAAK,KAEL7K,EAAA8K,GAAK,KAEL9K,EAAA+K,GAAK,KAEL/K,EAAAgL,GAAK,KAELhL,EAAAiL,GAAK,KAELjL,EAAAkL,GAAK,KAELlL,EAAAmL,GAAK,KAELnL,EAAAoL,GAAK,KAELpL,EAAAqL,GAAK,KAELrL,EAAAsL,GAAK,KAELtL,EAAAuL,GAAK,KAELvL,EAAAwL,GAAK,KAELxL,EAAAyL,GAAK,KAELzL,EAAA0L,GAAK,KAEL1L,EAAA2L,GAAK,KAEL3L,EAAA4L,GAAK,KAEL5L,EAAA6L,GAAK,KAtHK7L,GAydA8L,EAAAA,CAAAA,IACVA,EAAAC,MAAQ,QACRD,EAAAE,SAAW,WACXF,EAAAG,KAAO,OAHGH,GAAAA,CAAAA,GAAA,IAyiJAI,EAAAA,CAAAA,IACVA,EAAAnH,UAAY,YACZmH,EAAAlH,OAAS,SACTkH,EAAAjH,aAAe,gBAHLiH,GAAAA,CAAAA,GAAA,IA2CAC,EAAAA,CAAAA,IACVA,EAAAC,YAAc,cACdD,EAAAE,OAAS,SACTF,EAAAG,KAAO,OAHGH,GAAAA,CAAAA,GAAA,IAOAI,EAAAA,CAAAA,IAEVA,EAAAC,YAAc,cAEdD,EAAAE,OAAS,SAJCF,GAAAA,CAAAA,GAAA,IAQAG,EAAAA,CAAAA,IAEVA,EAAAC,UAAY,YAEZD,EAAAE,UAAY,YAEZF,EAAAG,UAAY,YAEZH,EAAAI,KAAO,OARGJ,GAAAA,CAAAA,GAAA,IAYAK,EAAAA,CAAAA,IAEVA,EAAAC,OAAS,SAETD,EAAAE,QAAU,UAEVF,EAAAG,SAAW,WAEXH,EAAAI,MAAQ,QAERJ,EAAAK,MAAQ,QAVEL,GAAAA,CAAAA,GAAA,IAcAM,GAAAA,CAAAA,IAEVA,EAAAjB,YAAc,cAEdiB,EAAAhB,OAAS,SAETgB,EAAAf,KAAO,OANGe,GAAAA,CAAAA,IAAA,IAiGAC,GAAAA,CAAAA,IAEVA,EAAAd,YAAc,cAEdc,EAAAb,OAAS,SAJCa,GAAAA,CAAAA,IAAA,IAQAC,GAAAA,CAAAA,IAEVA,EAAAnB,YAAc,cAEdmB,EAAAlB,OAAS,SAETkB,EAAAjB,KAAO,OANGiB,GAAAA,CAAAA,IAAA,IAUAC,GAAAA,CAAAA,IAEVA,EAAAhB,YAAc,cAEdgB,EAAAf,OAAS,SAJCe,GAAAA,CAAAA,IAAA,IAQAhO,KAAAA,EAAAA,IAAA,IAEVgH,SAAW,WAEXhH,EAAAiO,WAAa,cAEbjO,EAAAkO,cAAgB,kBAEhBlO,EAAAmO,sBAAwB,2BAExBnO,EAAAiH,aAAe,iBAEfjH,EAAAkH,WAAa,eAEblH,EAAAoO,YAAc,gBAEdpO,EAAAqO,aAAe,iBAhBLrO,GAsFAsO,GAAAA,CAAAA,IACVA,EAAAtN,KAAO,OACPsN,EAAApN,IAAM,MACNoN,EAAAC,eAAiB,iBACjBD,EAAAlN,IAAM,MAJIkN,GAAAA,CAAAA,IAAA,IAoBAE,GAAAA,CAAAA,IACVA,EAAAzH,UAAY,YACZyH,EAAAC,UAAY,YACZD,EAAAzN,QAAU,UAHAyN,GAAAA,CAAAA,IAAA,IA4YAE,GAAAA,CAAAA,IAEVA,EAAAC,MAAQ,QAERD,EAAAE,OAAS,SAETF,EAAAG,QAAU,UAEVH,EAAAI,QAAU,UAEVJ,EAAAK,SAAW,WAEXL,EAAAM,MAAQ,SAZEN,GAAAA,CAAAA,IAAA,IAgBAO,GAAAA,CAAAA,IAEVA,EAAAC,MAAQ,SAERD,EAAAE,cAAgB,gBAEhBF,EAAAG,IAAM,MAENH,EAAAI,IAAM,MAENJ,EAAAK,UAAY,aAEZL,EAAAM,mBAAqB,sBAErBN,EAAAO,MAAQ,SAdEP,GAAAA,CAAAA,IAAA,IAkBAQ,GAAAA,CAAAA,IAEVA,EAAAC,SAAW,WAEXD,EAAA7C,YAAc,cAEd6C,EAAAE,KAAO,OAEPF,EAAAG,MAAQ,QAERH,EAAA3C,KAAO,OAVG2C,GAAAA,CAAAA,IAAA,IAcAI,GAAAA,CAAAA,IAEVA,EAAAC,UAAY,YAEZD,EAAAE,iBAAmB,qBAEnBF,EAAAG,cAAgB,iBAEhBH,EAAAI,gBAAkB,mBARRJ,GAAAA,CAAAA,IAAA,IAYA9P,KAAAA,EAAAA,IAAA,IAEVmQ,IAAM,MAENnQ,EAAAoQ,IAAM,MAENpQ,EAAAqQ,IAAM,MAENrQ,EAAAsQ,IAAM,MAENtQ,EAAAuQ,IAAM,MAENvQ,EAAAwQ,IAAM,MAENxQ,EAAAyQ,IAAM,MAENzQ,EAAA0Q,IAAM,MAEN1Q,EAAA2Q,IAAM,MAEN3Q,EAAA4Q,IAAM,MAEN5Q,EAAA6Q,IAAM,MAEN7Q,EAAA8Q,IAAM,MAEN9Q,EAAA+Q,IAAM,MAEN/Q,EAAAgR,IAAM,MAENhR,EAAAiR,IAAM,MAENjR,EAAAkR,IAAM,MAENlR,EAAAmR,IAAM,MAENnR,EAAAoR,IAAM,MAENpR,EAAAqR,IAAM,MAENrR,EAAAsR,IAAM,MAENtR,EAAAuR,IAAM,MAENvR,EAAAwR,IAAM,MAENxR,EAAAyR,IAAM,MAENzR,EAAA0R,IAAM,MAEN1R,EAAA2R,IAAM,MAEN3R,EAAA4R,IAAM,MAEN5R,EAAA6R,IAAM,MAEN7R,EAAA8R,IAAM,MAEN9R,EAAA+R,IAAM,MAEN/R,EAAAgS,IAAM,MAENhS,EAAAiS,IAAM,MAENjS,EAAAkS,IAAM,MAENlS,EAAAmS,IAAM,MAENnS,EAAAoS,IAAM,MAENpS,EAAAqS,IAAM,MAENrS,EAAAsS,IAAM,MAENtS,EAAAuS,IAAM,MAENvS,EAAAwS,IAAM,MAENxS,EAAAyS,IAAM,MAENzS,EAAA0S,IAAM,MAEN1S,EAAA2S,IAAM,MAEN3S,EAAA4S,IAAM,MAEN5S,EAAA6S,IAAM,MAEN7S,EAAA8S,IAAM,MAEN9S,EAAA+S,IAAM,MAEN/S,EAAAgT,IAAM,MAENhT,EAAAiT,IAAM,MAENjT,EAAAkT,IAAM,MAENlT,EAAAmT,IAAM,MAENnT,EAAAoT,IAAM,MAENpT,EAAAqT,IAAM,MAENrT,EAAAsT,IAAM,MAENtT,EAAAuT,IAAM,MAENvT,EAAAwT,IAAM,MAENxT,EAAAyT,IAAM,MAENzT,EAAA0T,IAAM,MAEN1T,EAAA2T,IAAM,MAEN3T,EAAA4T,IAAM,MAEN5T,EAAA6T,IAAM,MAEN7T,EAAA8T,IAAM,MAEN9T,EAAA+T,IAAM,MAEN/T,EAAAgU,IAAM,MAENhU,EAAAiU,IAAM,MAENjU,EAAAkU,IAAM,MAENlU,EAAAmU,IAAM,MAENnU,EAAAoU,IAAM,MAENpU,EAAAqU,IAAM,MAENrU,EAAAsU,IAAM,MAENtU,EAAAuU,IAAM,MAENvU,EAAAwU,IAAM,MAENxU,EAAAyU,IAAM,MAENzU,EAAA0U,IAAM,MAEN1U,EAAA2U,IAAM,MAEN3U,EAAA4U,IAAM,MAEN5U,EAAA6U,IAAM,MAEN7U,EAAA8U,IAAM,MAEN9U,EAAA+U,IAAM,MAEN/U,EAAAgV,IAAM,MAENhV,EAAAiV,IAAM,MAENjV,EAAAkV,IAAM,MAENlV,EAAAmV,IAAM,MAENnV,EAAAoV,IAAM,MAENpV,EAAAqV,IAAM,MAENrV,EAAAsV,IAAM,MAENtV,EAAAuV,IAAM,MAENvV,EAAAwV,IAAM,MAENxV,EAAAyV,IAAM,MAENzV,EAAA0V,IAAM,MAEN1V,EAAA2V,IAAM,MAEN3V,EAAA4V,IAAM,MAEN5V,EAAA6V,IAAM,MAEN7V,EAAA8V,IAAM,MAEN9V,EAAA+V,IAAM,MAEN/V,EAAAgW,IAAM,MAENhW,EAAAiW,IAAM,MAENjW,EAAAkW,IAAM,MAENlW,EAAAmW,IAAM,MAENnW,EAAAoW,IAAM,MAENpW,EAAAqW,IAAM,MAENrW,EAAAsW,IAAM,MAENtW,EAAAuW,IAAM,MAENvW,EAAAwW,IAAM,MAENxW,EAAAyW,IAAM,MAENzW,EAAA0W,IAAM,MAEN1W,EAAA2W,IAAM,MAEN3W,EAAA4W,IAAM,MAEN5W,EAAA6W,IAAM,MAEN7W,EAAA8W,IAAM,MAEN9W,EAAA+W,IAAM,MAEN/W,EAAAgX,IAAM,MAENhX,EAAAiX,IAAM,MAENjX,EAAAkX,IAAM,MAENlX,EAAAmX,IAAM,MAENnX,EAAAoX,IAAM,MAENpX,EAAAqX,IAAM,MAENrX,EAAAsX,IAAM,MAENtX,EAAAuX,IAAM,MAENvX,EAAAwX,IAAM,MAENxX,EAAAyX,IAAM,MAENzX,EAAA0X,IAAM,MAEN1X,EAAA2X,IAAM,MAEN3X,EAAA4X,IAAM,MAEN5X,EAAA6X,IAAM,MAEN7X,EAAA8X,IAAM,MAEN9X,EAAA+X,IAAM,MAEN/X,EAAAgY,IAAM,MAENhY,EAAAiY,IAAM,MAENjY,EAAAkY,IAAM,MAENlY,EAAAmY,IAAM,MAENnY,EAAAoY,IAAM,MAENpY,EAAAqY,IAAM,MAENrY,EAAAsY,IAAM,MAENtY,EAAAuY,IAAM,MAENvY,EAAAwY,IAAM,MAENxY,EAAAyY,IAAM,MAENzY,EAAA0Y,IAAM,MAEN1Y,EAAA2Y,IAAM,MAEN3Y,EAAA4Y,IAAM,MAEN5Y,EAAA6Y,IAAM,MAEN7Y,EAAA8Y,IAAM,MAEN9Y,EAAA+Y,IAAM,MAEN/Y,EAAAgZ,IAAM,MAENhZ,EAAAiZ,IAAM,MAENjZ,EAAAkZ,IAAM,MAENlZ,EAAAmZ,IAAM,MAENnZ,EAAAoZ,IAAM,MAENpZ,EAAAqZ,IAAM,MAENrZ,EAAAsZ,IAAM,MAENtZ,EAAAuZ,IAAM,MAENvZ,EAAAwZ,IAAM,MAENxZ,EAAAyZ,IAAM,MAENzZ,EAAA0Z,IAAM,MAEN1Z,EAAA2Z,IAAM,MAEN3Z,EAAA4Z,IAAM,MAEN5Z,EAAA6Z,IAAM,MAEN7Z,EAAA8Z,IAAM,MAEN9Z,EAAA+Z,IAAM,MAEN/Z,EAAAga,IAAM,MAENha,EAAAia,IAAM,MAENja,EAAAka,IAAM,MAENla,EAAAma,IAAM,MAENna,EAAAoa,IAAM,MAENpa,EAAAqa,IAAM,MAENra,EAAAsa,IAAM,MAENta,EAAAua,IAAM,MAENva,EAAAwa,IAAM,MA5UIxa,GAgVAya,GAAAA,CAAAA,IAEVA,EAAAC,SAAW,WAEXD,EAAAE,YAAc,cAJJF,GAAAA,CAAAA,IAAA,IAQAG,GAAAA,CAAAA,IAEVA,EAAAC,yBAA2B,6BAE3BD,EAAAhX,8BAAgC,kCAJtBgX,GAAAA,CAAAA,IAAA,IAQAE,GAAAA,CAAAA,IAEVA,EAAAC,SAAW,WAEXD,EAAAE,UAAY,YAEZF,EAAAG,QAAU,UAEVH,EAAAI,GAAK,KARKJ,GAAAA,CAAAA,IAAA,IAYAK,GAAAA,CAAAA,IAEVA,EAAAC,MAAQ,QAERD,EAAAE,QAAU,UAEVF,EAAAG,KAAO,OAEPH,EAAAI,QAAU,UAEVJ,EAAAK,KAAO,OAVGL,GAAAA,CAAAA,IAAA,IAcAM,GAAAA,CAAAA,IAEVA,EAAAC,qBAAuB,yBAEvBD,EAAAE,kBAAoB,qBAEpBF,EAAAG,oBAAsB,wBAEtBH,EAAAI,mBAAqB,sBARXJ,GAAAA,CAAAA,IAAA,IAYA1b,KAAAA,EAAAA,IAAA,IAEV+b,QAAU,WAEV/b,EAAAgc,gBAAkB,oBAElBhc,EAAAic,KAAO,OAEPjc,EAAAkc,aAAe,gBAEflc,EAAAmc,QAAU,WAEVnc,EAAAoc,gBAAkB,oBAElBpc,EAAAqc,QAAU,WAEVrc,EAAAsc,gBAAkB,oBAElBtc,EAAAuc,QAAU,WAEVvc,EAAAwc,gBAAkB,oBAElBxc,EAAAyc,QAAU,WAtBAzc,GAslEA0c,GAAAA,CAAAA,IACVA,EAAAhb,KAAO,OACPgb,EAAA7W,MAAQ,QACR6W,EAAA5W,OAAS,SAHC4W,GAAAA,CAAAA,IAAA,IAqNAC,GAAAA,CAAAA,IAEVA,EAAAzW,aAAe,gBAEfyW,EAAAxW,iBAAmB,oBAEnBwW,EAAAvW,gBAAkB,mBAElBuW,EAAAtW,cAAgB,iBAEhBsW,EAAArW,QAAU,UAVAqW,GAAAA,CAAAA,IAAA,IAcAC,GAAAA,CAAAA,IAEVA,EAAAjW,UAAY,YAEZiW,EAAAhW,QAAU,UAEVgW,EAAA/V,OAAS,SAET+V,EAAA9V,SAAW,WAEX8V,EAAA7V,OAAS,SAVC6V,GAAAA,CAAAA,IAAA,IA4DA7c,KAAAA,EAAAA,IAAA,IAEV8c,eAAiB,kBAEjB9c,EAAA+c,eAAiB,kBAEjB/c,EAAAgd,eAAiB,kBAEjBhd,EAAAid,YAAc,eAEdjd,EAAAkd,YAAc,eAEdld,EAAAmd,YAAc,eAEdnd,EAAAod,gBAAkB,mBAElBpd,EAAAqd,gBAAkB,mBAElBrd,EAAAsd,gBAAkB,mBAElBtd,EAAAud,QAAU,WAEVvd,EAAAwd,UAAY,aAEZxd,EAAAyd,UAAY,aAEZzd,EAAA0d,UAAY,aAEZ1d,EAAA2d,UAAY,aAEZ3d,EAAA4d,UAAY,aAEZ5d,EAAA6d,UAAY,aAEZ7d,EAAA8d,UAAY,aAEZ9d,EAAA+d,UAAY,aAEZ/d,EAAAge,UAAY,aAEZhe,EAAAie,YAAc,eAEdje,EAAAke,YAAc,eAEdle,EAAAme,UAAY,aAEZne,EAAAoe,YAAc,eAEdpe,EAAAqe,SAAW,YAEXre,EAAAse,SAAW,YAEXte,EAAAue,SAAW,YAEXve,EAAAwe,WAAa,cAEbxe,EAAAye,WAAa,cAEbze,EAAA0e,WAAa,cAEb1e,EAAA2e,WAAa,cAEb3e,EAAA4e,WAAa,cAEb5e,EAAA6e,WAAa,cAEb7e,EAAA8e,WAAa,cAEb9e,EAAA+e,aAAe,gBAEf/e,EAAAgf,aAAe,gBAEfhf,EAAAif,WAAa,cAEbjf,EAAAkf,aAAe,gBA1ELlf,GA0FAD,KAAAA,EAAAA,IAAA,IAEVoB,KAAO,OAEPpB,EAAAsB,IAAM,MAENtB,EAAA4F,OAAS,SAET5F,EAAAof,WAAa,aAEbpf,EAAAqf,YAAc,cAEdrf,EAAAsf,aAAe,eAEftf,EAAAuf,aAAe,eAEfvf,EAAAwf,aAAe,eAEfxf,EAAAyf,MAAQ,QAERzf,EAAAwB,IAAM,MAENxB,EAAA0f,YAAc,cAEd1f,EAAA2f,oBAAsB,sBAEtB3f,EAAA4f,UAAY,YAEZ5f,EAAA6f,QAAU,UA5BA7f,GAgCA8f,GAAAA,CAAAA,IAEVA,EAAAC,OAAS,SAETD,EAAAE,WAAa,cAEbF,EAAAG,OAAS,SAETH,EAAAI,WAAa,aARHJ,GAAAA,CAAAA,IAAA,IAYAK,GAAAA,CAAAA,IAEVA,EAAA3E,QAAU,UAEV2E,EAAAC,IAAM,MAEND,EAAAjQ,UAAY,YAEZiQ,EAAAE,OAAS,SAETF,EAAAG,SAAW,YAEXH,EAAAI,OAAS,SAZCJ,GAAAA,CAAAA,IAAA,IAgBApgB,KAAAA,EAAAA,IAAA,IAEVqgB,IAAM,MAENrgB,EAAAygB,gBAAkB,mBAElBzgB,EAAA0gB,KAAO,OAEP1gB,EAAA2gB,OAAS,SAET3gB,EAAA4gB,YAAc,cAEd5gB,EAAAqb,QAAU,UAEVrb,EAAA6gB,QAAU,UAEV7gB,EAAA8gB,gBAAkB,mBAElB9gB,EAAA+gB,QAAU,UAEV/gB,EAAAghB,QAAU,WAEVhhB,EAAAihB,mBAAqB,sBAErBjhB,EAAAkhB,aAAe,gBAxBLlhB,GA4BAmhB,GAAAA,CAAAA,IAEVA,EAAAC,UAAY,aAEZD,EAAAnR,KAAO,OAEPmR,EAAAE,aAAe,gBANLF,GAAAA,CAAAA,IAAA,IAUAG,GAAAA,CAAAA,IAEVA,EAAAC,IAAM,MAEND,EAAAE,IAAM,MAENF,EAAAG,IAAM,MAENH,EAAAI,IAAM,MAENJ,EAAAK,IAAM,MAVIL,GAAAA,CAAAA,IAAA,IAcAM,GAAAA,CAAAA,IAEVA,EAAAC,QAAU,UAEVD,EAAAE,UAAY,YAJFF,GAAAA,CAAAA,IAAA,IAQAG,GAAAA,CAAAA,IAEVA,EAAA1a,SAAW,WAEX0a,EAAAxT,cAAgB,kBAEhBwT,EAAAvT,sBAAwB,2BAExBuT,EAAAza,aAAe,iBAEfya,EAAAxa,WAAa,eAEbwa,EAAAtT,YAAc,gBAEdsT,EAAArT,aAAe,iBAEfqT,EAAAC,aAAe,gBAhBLD,GAAAA,CAAAA,IAAA,IAoBAE,GAAAA,CAAAA,IAEVA,EAAAC,QAAU,WAEVD,EAAAE,WAAa,aAEbF,EAAAG,OAAS,SAETH,EAAAjU,MAAQ,QAERiU,EAAAI,WAAa,cAEbJ,EAAAK,mBAAqB,uBAErBL,EAAAM,SAAW,WAdDN,GAAAA,CAAAA,IAAA,IA42BAO,GAAAA,CAAAA,IAEVA,EAAAnb,SAAW,WAEXmb,EAAAhU,sBAAwB,2BAExBgU,EAAAjb,WAAa,eAEbib,EAAA/T,YAAc,gBAEd+T,EAAA9T,aAAe,iBAEf8T,EAAAC,gBAAkB,oBAElBD,EAAAE,kBAAoB,qBAdVF,GAAAA,CAAAA,IAAA,IAwCAG,GAAAA,CAAAA,IACVA,EAAAC,KAAO,OACPD,EAAAE,MAAQ,QACRF,EAAAG,QAAU,UACVH,EAAAI,OAAS,SACTJ,EAAAK,QAAU,UACVL,EAAAM,MAAQ,QANEN,GAAAA,CAAAA,IAAA,IA+TAO,GAAAA,CAAAA,IAEVA,EAAA3S,IAAM,MAEN2S,EAAA1S,IAAM,MAEN0S,EAAAzS,IAAM,MAENyS,EAAAxS,IAAM,MAENwS,EAAAvS,IAAM,MAENuS,EAAAtS,IAAM,MAENsS,EAAArS,IAAM,MAENqS,EAAApS,IAAM,MAENoS,EAAAnS,IAAM,MAENmS,EAAAlS,IAAM,MAENkS,EAAAjS,IAAM,MAENiS,EAAAhS,IAAM,MAENgS,EAAA/R,IAAM,MAEN+R,EAAA9R,IAAM,MAEN8R,EAAA7R,IAAM,MAEN6R,EAAA5R,IAAM,MAEN4R,EAAA3R,IAAM,MAEN2R,EAAA1R,IAAM,MAEN0R,EAAAzR,IAAM,MAENyR,EAAAxR,IAAM,MAENwR,EAAAvR,IAAM,MAENuR,EAAAtR,IAAM,MAENsR,EAAArR,IAAM,MAENqR,EAAApR,IAAM,MAENoR,EAAAnR,IAAM,MAENmR,EAAAlR,IAAM,MAENkR,EAAAjR,IAAM,MAENiR,EAAAhR,IAAM,MAENgR,EAAA/Q,IAAM,MAEN+Q,EAAA9Q,IAAM,MAEN8Q,EAAA7Q,IAAM,MAEN6Q,EAAA5Q,IAAM,MAEN4Q,EAAA3Q,IAAM,MAEN2Q,EAAA1Q,IAAM,MAEN0Q,EAAAzQ,IAAM,MAENyQ,EAAAxQ,IAAM,MAENwQ,EAAAvQ,IAAM,MAENuQ,EAAAtQ,IAAM,MAENsQ,EAAArQ,IAAM,MAENqQ,EAAApQ,IAAM,MAENoQ,EAAAnQ,IAAM,MAENmQ,EAAAlQ,IAAM,MAENkQ,EAAAjQ,IAAM,MAENiQ,EAAAhQ,IAAM,MAENgQ,EAAA/P,IAAM,MAEN+P,EAAA9P,IAAM,MAEN8P,EAAA7P,IAAM,MAEN6P,EAAA5P,IAAM,MAEN4P,EAAA3P,IAAM,MAEN2P,EAAA1P,IAAM,MAEN0P,EAAAzP,IAAM,MAENyP,EAAAxP,IAAM,MAENwP,EAAAvP,IAAM,MAENuP,EAAAtP,IAAM,MAENsP,EAAArP,IAAM,MAENqP,EAAApP,IAAM,MAENoP,EAAAnP,IAAM,MAENmP,EAAAlP,IAAM,MAENkP,EAAAjP,IAAM,MAENiP,EAAAhP,IAAM,MAENgP,EAAA/O,IAAM,MAEN+O,EAAA9O,IAAM,MAEN8O,EAAA7O,IAAM,MAEN6O,EAAA5O,IAAM,MAEN4O,EAAA3O,IAAM,MAEN2O,EAAA1O,IAAM,MAEN0O,EAAAzO,IAAM,MAENyO,EAAAxO,IAAM,MAENwO,EAAAvO,IAAM,MAENuO,EAAAtO,IAAM,MAENsO,EAAArO,IAAM,MAENqO,EAAApO,IAAM,MAENoO,EAAAnO,IAAM,MAENmO,EAAAlO,IAAM,MAENkO,EAAAjO,IAAM,MAENiO,EAAAhO,IAAM,MAENgO,EAAA/N,IAAM,MAEN+N,EAAA9N,IAAM,MAEN8N,EAAA7N,IAAM,MAEN6N,EAAA5N,IAAM,MAEN4N,EAAA3N,IAAM,MAEN2N,EAAA1N,IAAM,MAEN0N,EAAAzN,IAAM,MAENyN,EAAAxN,IAAM,MAENwN,EAAAvN,IAAM,MAENuN,EAAAtN,IAAM,MAENsN,EAAArN,IAAM,MAENqN,EAAApN,IAAM,MAENoN,EAAAnN,IAAM,MAENmN,EAAAlN,IAAM,MAENkN,EAAAjN,IAAM,MAENiN,EAAAhN,IAAM,MAENgN,EAAA/M,IAAM,MAEN+M,EAAA9M,IAAM,MAEN8M,EAAA7M,IAAM,MAEN6M,EAAA5M,IAAM,MAEN4M,EAAA3M,IAAM,MAEN2M,EAAA1M,IAAM,MAEN0M,EAAAzM,IAAM,MAENyM,EAAAxM,IAAM,MAENwM,EAAAvM,IAAM,MAENuM,EAAAtM,IAAM,MAENsM,EAAArM,IAAM,MAENqM,EAAApM,IAAM,MAENoM,EAAAnM,IAAM,MAENmM,EAAAlM,IAAM,MAENkM,EAAAjM,IAAM,MAENiM,EAAAhM,IAAM,MAENgM,EAAA/L,IAAM,MAEN+L,EAAA9L,IAAM,MAEN8L,EAAA7L,IAAM,MAEN6L,EAAA5L,IAAM,MAEN4L,EAAA3L,IAAM,MAEN2L,EAAA1L,IAAM,MAEN0L,EAAAzL,IAAM,MAENyL,EAAAxL,IAAM,MAENwL,EAAAvL,IAAM,MAENuL,EAAAtL,IAAM,MAENsL,EAAArL,IAAM,MAENqL,EAAApL,IAAM,MAENoL,EAAAnL,IAAM,MAENmL,EAAAlL,IAAM,MAENkL,EAAAjL,IAAM,MAENiL,EAAAhL,IAAM,MAENgL,EAAA/K,IAAM,MAEN+K,EAAA9K,IAAM,MAEN8K,EAAA7K,IAAM,MAEN6K,EAAA5K,IAAM,MAEN4K,EAAA3K,IAAM,MAEN2K,EAAA1K,IAAM,MAEN0K,EAAAzK,IAAM,MAENyK,EAAAxK,IAAM,MAENwK,EAAAvK,IAAM,MAENuK,EAAAtK,IAAM,MAENsK,EAAArK,IAAM,MAENqK,EAAApK,IAAM,MAENoK,EAAAnK,IAAM,MAENmK,EAAAlK,IAAM,MAENkK,EAAAjK,IAAM,MAENiK,EAAAhK,IAAM,MAENgK,EAAA/J,IAAM,MAEN+J,EAAA9J,IAAM,MAEN8J,EAAA7J,IAAM,MAEN6J,EAAA5J,IAAM,MAEN4J,EAAA3J,IAAM,MAEN2J,EAAA1J,IAAM,MAEN0J,EAAAzJ,IAAM,MAENyJ,EAAAxJ,IAAM,MAENwJ,EAAAvJ,IAAM,MAENuJ,EAAAtJ,IAAM,MAENsJ,EAAArJ,IAAM,MAENqJ,EAAApJ,IAAM,MAENoJ,EAAAnJ,IAAM,MAENmJ,EAAAlJ,IAAM,MAENkJ,EAAAjJ,IAAM,MAENiJ,EAAAhJ,IAAM,MAENgJ,EAAA/I,IAAM,MAEN+I,EAAA9I,IAAM,MAEN8I,EAAA7I,IAAM,MAEN6I,EAAA5I,IAAM,MAEN4I,EAAA3I,IAAM,MAEN2I,EAAA1I,IAAM,MAEN0I,EAAAzI,IAAM,MAENyI,EAAAxI,IAAM,MAENwI,EAAAvI,IAAM,MAENuI,EAAAtI,IAAM,MA5UIsI,GAAAA,CAAAA,IAAA,IAmgBAC,GAAAA,CAAAA,IACVA,EAAAP,KAAO,OACPO,EAAAJ,OAAS,SACTI,EAAAF,MAAQ,QAHEE,GAAAA,CAAAA,IAAA,IAMAC,GAAAA,CAAAA,IACVA,EAAAR,KAAO,OACPQ,EAAAL,OAAS,SACTK,EAAAH,MAAQ,QAHEG,GAAAA,CAAAA,IAAA,IAsBAC,GAAAA,CAAAA,IACVA,EAAAhiB,KAAO,OACPgiB,EAAA9hB,IAAM,MACN8hB,EAAAzU,eAAiB,iBACjByU,EAAAC,QAAU,UACVD,EAAA5hB,IAAM,MACN4hB,EAAAvD,QAAU,UANAuD,GAAAA,CAAAA,IAAA,IAkUAE,GAAAA,CAAAA,IAEVA,EAAApd,UAAY,aAEZod,EAAAnd,cAAgB,kBAJNmd,GAAAA,CAAAA,IAAA,IAQAC,GAAAA,CAAAA,IAEVA,EAAAnd,aAAe,gBAEfmd,EAAAld,iBAAmB,oBAEnBkd,EAAAjd,gBAAkB,mBAElBid,EAAAhd,cAAgB,iBAEhBgd,EAAA/c,QAAU,UAVA+c,GAAAA,CAAAA,IAAA,IAcAC,GAAAA,CAAAA,IAEVA,EAAA3c,UAAY,YAEZ2c,EAAA1c,QAAU,UAEV0c,EAAAzc,OAAS,SAETyc,EAAAxc,SAAW,WAEXwc,EAAAvc,OAAS,SAVCuc,GAAAA,CAAAA,IAAA,IA2zIL,MAAMC,GAA8GC,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2IpH,SAASC,GAAgCC,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAiFL,GAA6BI,EACvH,CAYD,MAAME,GAAuHL,EAAAA,EAAAA;;;;;;;;MAyB7H,SAASM,GAA+BJ,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmFC,GAAgCF,EAC5H,CAgBC,MAAMI,GAAkJP,EAAAA,EAAAA;;;;MAwBxJ,SAASQ,GAAyCN,GACjD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0GG,GAAuCJ,EAC1J,CAIC,MAAMM,GAA4FT,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;MAqClG,SAASU,GAAsBR,GAC9B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiEK,GAAuBN,EACjG,CAgBC,MAAMQ,GAA+FX,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;MA8CrG,SAASY,GAA2BV,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAuEO,GAAwBR,EACxG,CAYD,MAAMU,GAAwGb,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;MAwC9G,SAASc,GAA8BZ,GACpC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA6ES,GAA2BV,EACjH,CAYD,MAAMY,GAA4Ff,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAuClG,SAASgB,GAA0Bd,GAChC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAqEW,GAAuBZ,EACrG,CAYD,MAAMc,GAAyFjB,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;MA8C/F,SAASkB,GAAyBhB,GAC/B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAmEa,GAAsBd,EAClG,CAYD,MAAMgB,GAA4FnB,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0DlG,SAASoB,GAA0BlB,GAChC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAqEe,GAAuBhB,EACrG,CAYD,MAAMkB,GAAwGrB,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmG9G,SAASsB,GAA8BpB,GACpC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA6EiB,GAA2BlB,EACjH,CAYD,MAAMoB,GAAqGvB,EAAAA,EAAAA;;;;;;;;MA6B3G,SAASwB,GAA6BtB,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA2EmB,GAA0BpB,EAC9G,CAYD,MAAMsB,GAAyFzB,EAAAA,EAAAA;;;;;;;;;;;;MAkC/F,SAAS0B,GAAyBxB,GAC/B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAmEqB,GAAsBtB,EAClG,CAYD,MAAMwB,GAAuH3B,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoI7H,SAAS4B,GAAmC1B,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAuFuB,GAAgCxB,EAChI,CAYD,MAAM0B,GAAoH7B,EAAAA,EAAAA;;;;MA0B1H,SAAS8B,GAA+B5B,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsFyB,GAA6B1B,EAC5H,CAIC,MAAM4B,GAA4F/B,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;MAwClG,SAASgC,GAAsB9B,GAC9B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiE2B,GAAuB5B,EACjG,CAgBC,MAAM8B,GAAoHjC,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuG1H,SAASkC,GAA8BhC,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiF6B,GAA+B9B,EACzH,CACC,SAASgC,GAAkCjC,GACxC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAqF6B,GAA+B9B,EAC7H,CAYD,MAAMiC,GAA0HpC,EAAAA,EAAAA;;;;MAyBhI,SAASqC,GAAiCnC,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0FgC,GAA+BjC,EAClI,CAIC,MAAMmC,GAAmFtC,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8KzF,SAASuC,GAAmBrC,GAC3B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2DkC,GAAoBnC,EACxF,CAgBC,MAAMqC,GAAsFxC,EAAAA,EAAAA;;;;;;;;;MAgC5F,SAASyC,GAAqBvC,GAC7B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkEoC,GAAmBrC,EAC9F,CAIC,MAAMuC,GAAmI1C,EAAAA,EAAAA;;;;MAwBzI,SAAS2C,GAAoCzC,GAC5C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgGsC,GAAkCvC,EAC3I,CAIC,MAAMyC,GAAwG5C,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwM9G,SAAS6C,GAA0B3C,GAClC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAyEwC,GAA2BzC,EAC7G,CAgBC,MAAM2C,GAAwJ9C,EAAAA,EAAAA;;;;;;;;MA8B9J,SAAS+C,GAA2C7C,GACnD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8G0C,GAAyC3C,EAChK,CAIC,MAAM6C,GAA2GhD,EAAAA,EAAAA;;;;MAwBjH,SAASiD,GAA4B/C,GACpC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgF4C,GAA0B7C,EACnH,CAIC,MAAM+C,GAAoHlD,EAAAA,EAAAA;;;;;;;;MA6B1H,SAASmD,GAA+BjD,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsF8C,GAA6B/C,EAC5H,CAIC,MAAMiD,GAAqGpD,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwM3G,SAASqD,GAAyBnD,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuEgD,GAA0BjD,EAC1G,CAgBC,MAAMmD,GAAqJtD,EAAAA,EAAAA;;;;;;;;MA8B3J,SAASuD,GAA0CrD,GAClD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4GkD,GAAwCnD,EAC7J,CAIC,MAAMqD,GAAwGxD,EAAAA,EAAAA;;;;MAwB9G,SAASyD,GAA2BvD,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8EoD,GAAyBrD,EAChH,CAIC,MAAMuD,GAAiH1D,EAAAA,EAAAA;;;;;;;;MA6BvH,SAAS2D,GAA8BzD,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoFsD,GAA4BvD,EACzH,CAIC,MAAMyD,GAA6H5D,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmKnI,SAAS6D,GAAiC3D,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuFwD,GAAkCzD,EAClI,CAgBC,MAAM2D,GAA8J9D,EAAAA,EAAAA;;;;;;;;;MA8BpK,SAAS+D,GAA6C7D,GACrD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkH0D,GAA2C3D,EACtK,CAIC,MAAM6D,GAAiHhE,EAAAA,EAAAA;;;;;;MA0BvH,SAASiE,GAA8B/D,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoF4D,GAA4B7D,EACzH,CAIC,MAAM+D,GAA8GlE,EAAAA,EAAAA;;;;;;MA2BpH,SAASmE,GAA6BjE,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkF8D,GAA2B/D,EACtH,CAIC,MAAMiE,GAAsIpE,EAAAA,EAAAA;;;;;;;;MA6B5I,SAASqE,GAAqCnE,GAC7C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkGgE,GAAmCjE,EAC9I,CAIC,MAAMmE,GAA0HtE,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmJhI,SAASuE,GAAgCrE,GACxC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAqFkE,GAAiCnE,EAC/H,CAgBC,MAAMqE,GAA2JxE,EAAAA,EAAAA;;;;;;;;;MA8BjK,SAASyE,GAA4CvE,GACpD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgHoE,GAA0CrE,EACnK,CAIC,MAAMuE,GAA8G1E,EAAAA,EAAAA;;;;;;MA0BpH,SAAS2E,GAA6BzE,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkFsE,GAA2BvE,EACtH,CAIC,MAAMyE,GAA2G5E,EAAAA,EAAAA;;;;;;MA2BjH,SAAS6E,GAA4B3E,GACpC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgFwE,GAA0BzE,EACnH,CAIC,MAAM2E,GAA8G9E,EAAAA,EAAAA;;;;;;;;MA6BpH,SAAS+E,GAA6B7E,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkF0E,GAA2B3E,EACtH,CAIC,MAAM6E,GAAqGhF,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsM3G,SAASiF,GAAyB/E,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuE4E,GAA0B7E,EAC1G,CAgBC,MAAM+E,GAAqJlF,EAAAA,EAAAA;;;;;;;;MA8B3J,SAASmF,GAA0CjF,GAClD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4G8E,GAAwC/E,EAC7J,CAIC,MAAMiF,GAAwGpF,EAAAA,EAAAA;;;;MAwB9G,SAASqF,GAA2BnF,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8EgF,GAAyBjF,EAChH,CAIC,MAAMmF,GAAiHtF,EAAAA,EAAAA;;;;;;;;MA6BvH,SAASuF,GAA8BrF,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoFkF,GAA4BnF,EACzH,CAIC,MAAMqF,GAAuHxF,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4M7H,SAASyF,GAA+BvF,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmFoF,GAAgCrF,EAC5H,CAgBC,MAAMuF,GAAmL1F,EAAAA,EAAAA;;;;;;;;;;;;MAiCzL,SAAS2F,GAAoDzF,GAC5D,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgIsF,GAAkDvF,EAC3L,CAIC,MAAMyF,GAAsI5F,EAAAA,EAAAA;;;;;;MA0B5I,SAAS6F,GAAqC3F,GAC7C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkGwF,GAAmCzF,EAC9I,CAIC,MAAM2F,GAAyI9F,EAAAA,EAAAA;;;;;;;;MA4B/I,SAAS+F,GAAsC7F,GAC9C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoG0F,GAAoC3F,EACjJ,CAIC,MAAM6F,GAAgIhG,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuItI,SAASiG,GAAsC/F,GAC5C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA6F4F,GAAmC7F,EACzI,CAYD,MAAM+F,GAA0HlG,EAAAA,EAAAA;;;;;;;;;;;;;MA+BhI,SAASmG,GAAgCjG,GACxC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAqF8F,GAAiC/F,EAC/H,CAgBC,MAAMiG,GAAwGpG,EAAAA,EAAAA;;;;;;;;MA8B9G,SAASqG,GAA2BnG,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8EgG,GAAyBjG,EAChH,CAIC,MAAMmG,GAA2GtG,EAAAA,EAAAA;;;;MA0BjH,SAASuG,GAA+BrG,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA+EkG,GAA4BnG,EACpH,CAYD,MAAMqG,GAAuHxG,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;MAyC7H,SAASyG,GAA+BvG,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmFoG,GAAgCrG,EAC5H,CAgBC,MAAMuG,GAA2G1G,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwDjH,SAAS2G,GAA2BzG,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2EsG,GAA4BvG,EAChH,CAgBC,MAAMyG,GAAgI5G,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyDtI,SAAS6G,GAAsC3G,GAC5C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA6FwG,GAAmCzG,EACzI,CAYD,MAAM2G,GAA0H9G,EAAAA,EAAAA;;;;;;;;MA8BhI,SAAS+G,GAAiC7G,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0F0G,GAA+B3G,EAClI,CAIC,MAAM6G,GAAiKhH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;MAyCvK,SAASiH,GAA6C/G,GACrD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA+G4G,GAA8C7G,EACtK,CAgBC,MAAM+G,GAAuKlH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgP7K,SAASmH,GAAmDjH,GACzD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAuH8G,GAAgD/G,EAChL,CAYD,MAAMiH,GAA4FpH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiElG,SAASqH,GAAsBnH,GAC9B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiEgH,GAAuBjH,EACjG,CAgBC,MAAMmH,GAAoHtH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+F1H,SAASuH,GAA8BrH,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiFkH,GAA+BnH,EACzH,CAgBC,MAAMqH,GAA2JxH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2EjK,SAASyH,GAA2CvH,GACnD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2GoH,GAA4CrH,EAChK,CAgBC,MAAMuH,GAAqG1H,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgD3G,SAAS2H,GAAyBzH,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuEsH,GAA0BvH,EAC1G,CAgBC,MAAMyH,GAAiH5H,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8DvH,SAAS6H,GAA6B3H,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA+EwH,GAA8BzH,EACtH,CAgBC,MAAM2H,GAA6H9H,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqInI,SAAS+H,GAAqC7H,GAC3C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA2F0H,GAAkC3H,EACtI,CAYD,MAAM6H,GAAuHhI,EAAAA,EAAAA;;;;;;;;;;;;;MA+B7H,SAASiI,GAA+B/H,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmF4H,GAAgC7H,EAC5H,CAgBC,MAAM+H,GAAyIlI,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkI/I,SAASmI,GAAyCjI,GAC/C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAmG8H,GAAsC/H,EAClJ,CAYD,MAAMiI,GAAmIpI,EAAAA,EAAAA;;;;;;;;;;;;;MA+BzI,SAASqI,GAAmCnI,GAC3C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2FgI,GAAoCjI,EACxI,CAgB6FH,EAAAA,EAAAA;;;;;;;;MA4C5F,MAAMsI,GAA+FtI,EAAAA,EAAAA;;;;MAyBrG,SAASuI,GAA2BrI,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAuEkI,GAAwBnI,EACxG,CAY8FH,EAAAA,EAAAA;;;;;;MA0C/F,MAAMwI,GAAiHxI,EAAAA,EAAAA;;;;MAuBvH,SAASyI,GAA8BvI,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoFoI,GAA4BrI,EACzH,CAIC,MAAMuI,GAAiH1I,EAAAA,EAAAA;;;;MAwBvH,SAAS2I,GAA8BzI,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoFsI,GAA4BvI,EACzH,CAIC,MAAMyI,GAAuH5I,EAAAA,EAAAA;;;;;;;;MA8B7H,SAAS6I,GAAgC3I,GACxC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAwFwI,GAA8BzI,EAC/H,CAIwHH,EAAAA,EAAAA;;;;MA+BvH,MAAM8I,GAAmI9I,EAAAA,EAAAA;;;;MAuBzI,SAAS+I,GAAoC7I,GAC5C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgG0I,GAAkC3I,EAC3I,CAIC,MAAM6I,GAA2GhJ,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8FjH,SAASiJ,GAA+B/I,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA+E4I,GAA4B7I,EACpH,CAYD,MAAM+I,GAAmFlJ,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA0CzF,SAASmJ,GAAmBjJ,GAC3B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2D8I,GAAoB/I,EACxF,CAgBC,MAAMiJ,GAAqGpJ,EAAAA,EAAAA;;;;;;;;;MA+B3G,SAASqJ,GAA6BnJ,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA2EgJ,GAA0BjJ,EAC9G,CAYD,MAAMmJ,GAAwGtJ,EAAAA,EAAAA;;;;MAwB9G,SAASuJ,GAA2BrJ,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8EkJ,GAAyBnJ,EAChH,CAIC,MAAMqJ,GAA4FxJ,EAAAA,EAAAA;;;;MAyBlG,SAASyJ,GAAuBvJ,GAC/B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsEoJ,GAAqBrJ,EACpG,CAIC,MAAMuJ,GAAoH1J,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmD1H,SAAS2J,GAA8BzJ,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiFsJ,GAA+BvJ,EACzH,CAgBC,MAAMyJ,GAAsF5J,EAAAA,EAAAA;;;;;;;;;;;MA6B5F,SAAS6J,GAAoB3J,GAC5B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6DwJ,GAAqBzJ,EAC3F,CAgBC,MAAM2J,GAAiH9J,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8DvH,SAAS+J,GAAiC7J,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAmF0J,GAA8B3J,EAC1H,CAYD,MAAM6J,GAAuHhK,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;MA2C7H,SAASiK,GAA+B/J,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmF4J,GAAgC7J,EAC5H,CAgBC,MAAM+J,GAA6HlK,EAAAA,EAAAA;;;;MAyBnI,SAASmK,GAAkCjK,GAC1C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4F8J,GAAgC/J,EACrI,CAIC,MAAMiK,GAAiHpK,EAAAA,EAAAA;;;;MAwBvH,SAASqK,GAA8BnK,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoFgK,GAA4BjK,EACzH,CAIC,MAAMmK,GAAmItK,EAAAA,EAAAA;;;;MAwBzI,SAASuK,GAAoCrK,GAC5C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgGkK,GAAkCnK,EAC3I,CAIC,MAAMqK,GAAqGxK,EAAAA,EAAAA;;;;;;;MA2B3G,SAASyK,GAAyBvK,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuEoK,GAA0BrK,EAC1G,CAgBC,MAAMuK,GAAkJ1K,EAAAA,EAAAA;;;;;;;;;;;;;;;;;MAqCxJ,SAAS2K,GAAwCzK,GAChD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAqGsK,GAAyCvK,EACvJ,CAgBC,MAAMyK,GAAoH5K,EAAAA,EAAAA;;;;;;;;;;;MAkC1H,SAAS6K,GAA+B3K,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsFwK,GAA6BzK,EAC5H,CAIC,MAAM2K,GAAoH9K,EAAAA,EAAAA;;;;MAwB1H,SAAS+K,GAA+B7K,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsF0K,GAA6B3K,EAC5H,CAIC,MAAM6K,GAAsIhL,EAAAA,EAAAA;;;;;;;MA4B5I,SAASiL,GAAqC/K,GAC7C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkG4K,GAAmC7K,EAC9I,CAIC,MAAM+K,GAA+FlL,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2DrG,SAASmL,GAAuBjL,GAC/B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmE8K,GAAwB/K,EACpG,CAgBC,MAAMiL,GAAiHpL,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuDvH,SAASqL,GAA6BnL,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA+EgL,GAA8BjL,EACtH,CAgBC,MAAMmL,GAAgLtL,EAAAA,EAAAA;;;;;;;;;;;;;MA8BtL,SAASuL,GAAkDrL,GAC1D,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAyHkL,GAAmDnL,EACrL,CAgBC,MAAMqL,GAAwGxL,EAAAA,EAAAA;;;;;;;;MA4B9G,SAASyL,GAA2BvL,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8EoL,GAAyBrL,EAChH,CAIC,MAAMuL,GAAsF1L,EAAAA,EAAAA;;;;;;;;;;;;;;MAiC5F,SAAS2L,GAAoBzL,GAC5B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6DsL,GAAqBvL,EAC3F,CAgBC,MAAMyL,GAAkG5L,EAAAA,EAAAA;;;;MAwBxG,SAAS6L,GAAyB3L,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0EwL,GAAuBzL,EAC1G,CAIC,MAAM2L,GAAkG9L,EAAAA,EAAAA;;;;MA0BxG,SAAS+L,GAAyB7L,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0E0L,GAAuB3L,EAC1G,CAIC,MAAM6L,GAAgFhM,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4GtF,SAASiM,GAAkB/L,GAC1B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAyD4L,GAAmB7L,EACrF,CAgBC,MAAM+L,GAA8GlM,EAAAA,EAAAA;;;;MAwBpH,SAASmM,GAA6BjM,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkF8L,GAA2B/L,EACtH,CAIC,MAAMiM,GAAqGpM,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA2C3G,SAASqM,GAAyBnM,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuEgM,GAA0BjM,EAC1G,CAgBC,MAAMmM,GAA8JtM,EAAAA,EAAAA;;;;;;;;MA8BpK,SAASuM,GAA6CrM,GACrD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkHkM,GAA2CnM,EACtK,CAI4JH,EAAAA,EAAAA;;;;;;MA2CxBA,EAAAA,EAAAA;;;;;;MA2CMA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;MA4DZA,EAAAA,EAAAA;;;;;;;;;;MA+CMA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;MA4DNA,EAAAA,EAAAA;;;;;;;;;;;MAgDfA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;MA0D0CA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;MAwDfA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;MAyDTA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;MA+DyDA,EAAAA,EAAAA;;;;MAyCzL,MAAMwM,GAAmFxM,EAAAA,EAAAA;;;;MAyCnFyM,GAAsFzM,EAAAA,EAAAA;;;;MAyCtF0M,GAA6H1M,EAAAA,EAAAA;;;;MAwC7H2M,GAAiH3M,EAAAA,EAAAA;;;;MAwCjH4M,GAAiH5M,EAAAA,EAAAA;;;;MAyCjH6M,GAAyI7M,EAAAA,EAAAA;;;;MAwCzI8M,GAA+I9M,EAAAA,EAAAA;;;;MAwC/I+M,GAAoH/M,EAAAA,EAAAA;;;;;;;;;;;;;;;MAmC1H,SAASgN,GAA+B9M,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsF2M,GAA6B5M,EAC5H,CAIC,MAAM8M,GAA2GjN,EAAAA,EAAAA;;;;MA+B3GkN,GAA6HlN,EAAAA,EAAAA;;;;MAyC7HmN,GAAwGnN,EAAAA,EAAAA;;;;;;;;;;;;;;;MAsDxGoN,GAAqGpN,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;MA4DrGqN,GAAsIrN,EAAAA,EAAAA;;;;MA8BhDA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkEMA,EAAAA,EAAAA;;;;;;;;;;;;MAiDNA,EAAAA,EAAAA;;;;;;;;;;MAgDNA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA+D6CA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsENA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;MAwD7H,MAAMsN,GAA0HtN,EAAAA,EAAAA;;;;;;;;;;;;MAgChI,SAASuN,GAAgCrN,GACxC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAqFkN,GAAiCnN,EAC/H,CAgB4GH,EAAAA,EAAAA;;;;;;;MA8CkBA,EAAAA,EAAAA;;;;MAyC7H,MAAMwN,GAAkGxN,EAAAA,EAAAA;;;;;;;MAyBxG,SAASyN,GAAwBvN,GAChC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAqEoN,GAAyBrN,EACvG,CACC,SAASuN,GAA4BxN,GAClC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAyEoN,GAAyBrN,EAC3G,CAYgHH,EAAAA,EAAAA;;;;;;;;;;;;;;;MAoDjH,MAAM2N,GAA+F3N,EAAAA,EAAAA;;;;;;;;;;;;;;MAqCrG,SAAS4N,GAAwB1N,GAChC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAwEuN,GAAsBxN,EACvG,CAI8HH,EAAAA,EAAAA;;;;;;;;;;MAuCrBA,EAAAA,EAAAA;;;;;;;;;MAqCkBA,EAAAA,EAAAA;;;;;;;;;MAqC1H,MAAM6N,GAAqG7N,EAAAA,EAAAA;;;;;;MA0B3G,SAAS8N,GAA0B5N,GAClC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4EyN,GAAwB1N,EAC7G,CAIC,MAAM4N,GAAqG/N,EAAAA,EAAAA;;;;;;MA2B3G,SAASgO,GAA0B9N,GAClC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4E2N,GAAwB5N,EAC7G,CAIiLH,EAAAA,EAAAA;;;;;;;;;;;;;;MA+CTA,EAAAA,EAAAA;;;;;;;;;;;;MA6CtDA,EAAAA,EAAAA;;;;;;MAkC8BA,EAAAA,EAAAA;;;;;;MAkClBA,EAAAA,EAAAA;;;;;;;;;;;;;;MA+CHA,EAAAA,EAAAA;;;;;;;;;;MAuCoCA,EAAAA,EAAAA;;;;MA+B3BA,EAAAA,EAAAA;;;;MA+B6CA,EAAAA,EAAAA;;;;;;;;;MAuChL,MAAMiO,GAAwGjO,EAAAA,EAAAA;;;;;;MA0B9G,SAASkO,GAA2BhO,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8E6N,GAAyB9N,EAChH,CAIC,MAAMgO,GAAmInO,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAoCzI,SAASoO,GAAmClO,GAC3C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2F+N,GAAoChO,EACxI,CAgBC,MAAMkO,GAAwGrO,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+E9G,SAASsO,GAA0BpO,GAClC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAyEiO,GAA2BlO,EAC7G,CAgBC,MAAMoO,GAAwJvO,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiD9J,SAASwO,GAA0CtO,GAClD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAyGmO,GAA2CpO,EAC7J,CAgBC,MAAMsO,GAA8JzO,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiDpK,SAAS0O,GAA4CxO,GACpD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6GqO,GAA6CtO,EACnK,CAgBC,MAAMwO,GAAkJ3O,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;MA2CxJ,SAAS4O,GAAwC1O,GAChD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAqGuO,GAAyCxO,EACvJ,CAgBC,MAAM0O,GAAqJ7O,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAkC3J,SAAS8O,GAAyC5O,GACjD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuGyO,GAA0C1O,EAC1J,CAgBC,MAAM4O,GAA8J/O,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsDpK,SAASgP,GAA4C9O,GACpD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6G2O,GAA6C5O,EACnK,CAgBC,MAAM8O,GAAyLjP,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA4C/L,SAASkP,GAAqDhP,GAC7D,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA+H6O,GAAsD9O,EAC9L,CAgBC,MAAMgP,GAA+LnP,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA4CrM,SAASoP,GAAuDlP,GAC/D,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmI+O,GAAwDhP,EACpM,CAgBC,MAAMkP,GAAqMrP,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA4C3M,SAASsP,GAAyDpP,GACjE,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuIiP,GAA0DlP,EAC1M,CAgBC,MAAMoP,GAA4LvP,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;MA8ClM,SAASwP,GAAsDtP,GAC9D,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiImP,GAAuDpP,EACjM,CAgBC,MAAMsP,GAAsLzP,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA4C5L,SAAS0P,GAAoDxP,GAC5D,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6HqP,GAAqDtP,EAC3L,CAgBC,MAAMwP,GAAuK3P,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqD7K,SAAS4P,GAA+C1P,GACvD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmHuP,GAAgDxP,EAC5K,CAgBC,MAAM0P,GAA0H7P,EAAAA,EAAAA;;;;;;;;;;MAkChI,SAAS8P,GAAiC5P,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0FyP,GAA+B1P,EAClI,CAIC,MAAM4P,GAAuH/P,EAAAA,EAAAA;;;;MAyB7H,SAASgQ,GAAgC9P,GACxC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAwF2P,GAA8B5P,EAC/H,CAIC,MAAM8P,GAA+IjQ,EAAAA,EAAAA;;;;;;;;;;MAkCrJ,SAASkQ,GAAwChQ,GAChD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAwG6P,GAAsC9P,EACvJ,CAIC,MAAMgQ,GAAqJnQ,EAAAA,EAAAA;;;;;;;;;;;;MAsC3J,SAASoQ,GAA0ClQ,GAClD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4G+P,GAAwChQ,EAC7J,CAIC,MAAMkQ,GAA4IrQ,EAAAA,EAAAA;;;;;;;;;MAgClJ,SAASsQ,GAAuCpQ,GAC/C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsGiQ,GAAqClQ,EACpJ,CAIC,MAAMoQ,GAA0HvQ,EAAAA,EAAAA;;;;;;;;;;MAkChI,SAASwQ,GAAiCtQ,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0FmQ,GAA+BpQ,EAClI,CAIC,MAAMsQ,GAAmFzQ,EAAAA,EAAAA;;;;;;;;;MAgCzF,SAAS0Q,GAAoBxQ,GAC5B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgEqQ,GAAkBtQ,EAC3F,CAIC,MAAMwQ,GAA2G3Q,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;MA0DjH,SAAS4Q,GAA4B1Q,GACpC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgFuQ,GAA0BxQ,EACnH,CAIC,MAAM0Q,GAAyF7Q,EAAAA,EAAAA;;;;MAwB/F,SAAS8Q,GAAsB5Q,GAC9B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoEyQ,GAAoB1Q,EACjG,CAIC,MAAM4Q,GAA0H/Q,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgEhI,SAASgR,GAAgC9Q,GACxC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAqF2Q,GAAiC5Q,EAC/H,CAgBC,MAAM8Q,GAAqJjR,EAAAA,EAAAA;;;;;;;;;MA+B3J,SAASkR,GAA6ChR,GACnD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA2G6Q,GAA0C9Q,EAC9J,CAYD,MAAMgR,GAAgInR,EAAAA,EAAAA;;;;;;;;MA8BtI,SAASoR,GAAmClR,GAC3C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8F+Q,GAAiChR,EACxI,CAIC,MAAMkR,GAAqGrR,EAAAA,EAAAA;;;;;;;;MA8B3G,SAASsR,GAA0BpR,GAClC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4EiR,GAAwBlR,EAC7G,CAIC,MAAMoR,GAAoHvR,EAAAA,EAAAA;;;;;;;;MA8B1H,SAASwR,GAA+BtR,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsFmR,GAA6BpR,EAC5H,CAI2HH,EAAAA,EAAAA;;;;MAgC3BA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA6DHA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsJeA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6HiCA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkH9BA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuGkBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;MA0DGA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;MA0DnI,MAAMyR,GAAqGzR,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuD3G,SAAS0R,GAAyBxR,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuEqR,GAA0BtR,EAC1G,CAgBC,MAAMwR,GAAgF3R,EAAAA,EAAAA;;;;;;;;;MAgCtF,SAAS4R,GAAmB1R,GAC3B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8DuR,GAAiBxR,EACxF,CAIC,MAAM0R,GAAwG7R,EAAAA,EAAAA;;;;;;;;;;;;;;;;;MA8C9G,SAAS8R,GAA2B5R,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8EyR,GAAyB1R,EAChH,CAIC,MAAM4R,GAAsF/R,EAAAA,EAAAA;;;;MAwB5F,SAASgS,GAAqB9R,GAC7B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkE2R,GAAmB5R,EAC9F,CAI6FH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA6DYA,EAAAA,EAAAA;;;;;;;MA8CTA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4GSA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4EiCA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA8G9BA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsGkBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;MA0D1CA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiLwEA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoEGA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmFfA,EAAAA,EAAAA;;;;;;;;;;;;;MAkDAA,EAAAA,EAAAA;;;;MA+BNA,EAAAA,EAAAA;;;;;;;;MAqC2BA,EAAAA,EAAAA;;;;;;;;MAqCZA,EAAAA,EAAAA;;;;;;;;MAqCYA,EAAAA,EAAAA;;;;;;;;MAqCAA,EAAAA,EAAAA;;;;MA+BMA,EAAAA,EAAAA;;;;;;;;;MAuCNA,EAAAA,EAAAA;;;;;;;;;MAuCMA,EAAAA,EAAAA;;;;MAgC9BA,EAAAA,EAAAA;;;;;;;MAmC5I,MAAMiS,GAA4IjS,EAAAA,EAAAA;;;;MAwBlJ,SAASkS,GAAuChS,GAC/C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsG6R,GAAqC9R,EACpJ,CAIqKH,EAAAA,EAAAA;;;;MAgCpK,MAAMmS,GAA8GnS,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;MAyCpH,SAASoS,GAA4BlS,GACpC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6E+R,GAA6BhS,EACnH,CAgBC,MAAMkS,GAA4FrS,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;MAmDlG,SAASsS,GAAuBpS,GAC/B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsEiS,GAAqBlS,EACpG,CAIC,MAAMoS,GAA4FvS,EAAAA,EAAAA;;;;;;;;;;;;;;;;;MAgDlG,SAASwS,GAAuBtS,GAC/B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsEmS,GAAqBpS,EACpG,CAIC,MAAMsS,GAAkGzS,EAAAA,EAAAA;;;;MAwBxG,SAAS0S,GAAyBxS,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0EqS,GAAuBtS,EAC1G,CAIC,MAAMwS,GAA6H3S,EAAAA,EAAAA;;;;MAwBnI,SAAS4S,GAAkC1S,GAC1C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4FuS,GAAgCxS,EACrI,CAIC,MAAM0S,GAAsI7S,EAAAA,EAAAA;;;;MAyB5I,SAAS8S,GAAqC5S,GAC7C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkGyS,GAAmC1S,EAC9I,CAIC,MAAM4S,GAAqJ/S,EAAAA,EAAAA;;;;;;;MA4B3J,SAASgT,GAA0C9S,GAClD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4G2S,GAAwC5S,EAC7J,CAIC,MAAM8S,GAAwGjT,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;MA8C9G,SAASkT,GAA0BhT,GAClC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAyE6S,GAA2B9S,EAC7G,CAgBC,MAAMgT,GAAkJnT,EAAAA,EAAAA;;;;MAsBxJ,SAASoT,GAAwClT,GAChD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAqG+S,GAAyChT,EACvJ,CAgBC,MAAMkT,GAAgIrT,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgHtI,SAASsT,GAAkCpT,GAC1C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAyFiT,GAAmClT,EACrI,CAgBC,MAAMoT,GAA+IvT,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;MA+CrJ,SAASwT,GAAuCtT,GAC/C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmGmT,GAAwCpT,EACpJ,CAgBC,MAAMsT,GAA8GzT,EAAAA,EAAAA;;;;;;;;;MAuC9G0T,GAAwG1T,EAAAA,EAAAA;;;;;;;;;MAuCxG2T,GAA8G3T,EAAAA,EAAAA;;;;MA+B9G4T,GAAyF5T,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqEzF6T,GAAsF7T,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgE5F,SAAS8T,GAAoB5T,GAC5B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6DyT,GAAqB1T,EAC3F,CAgBC,MAAM4T,GAAmF/T,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqFzF,SAASgU,GAAmB9T,GAC3B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2D2T,GAAoB5T,EACxF,CAgBiFH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;MAsDYA,EAAAA,EAAAA;;;;;;MAiC5F,MAAMiU,GAA6HjU,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;MA6CnI,SAASkU,GAAiChU,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuF6T,GAAkC9T,EAClI,CAgB8HH,EAAAA,EAAAA;;;;;;;MA4C7H,MAAMmU,GAA8GnU,EAAAA,EAAAA;;;;;;;;;;;MA8BpH,SAASoU,GAA4BlU,GACpC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6E+T,GAA6BhU,EACnH,CAgBC,MAAMkU,GAA+FrU,EAAAA,EAAAA;;;;;;;;;;;MA6BrG,SAASsU,GAAuBpU,GAC/B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmEiU,GAAwBlU,EACpG,CAgBC,MAAMoU,GAA2GvU,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;MAoDjH,SAASwU,GAA4BtU,GACpC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgFmU,GAA0BpU,EACnH,CAIC,MAAMsU,GAAqGzU,EAAAA,EAAAA;;;;;;;;;;;;;;MA0C3G,SAAS0U,GAA0BxU,GAClC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4EqU,GAAwBtU,EAC7G,CAIC,MAAMwU,GAAiH3U,EAAAA,EAAAA;;;;;;;;;MAgCvH,SAAS4U,GAA8B1U,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoFuU,GAA4BxU,EACzH,CAIC,MAAM0U,GAA0H7U,EAAAA,EAAAA;;;;MAyBhI,SAAS8U,GAAiC5U,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0FyU,GAA+B1U,EAClI,CAIC,MAAM4U,GAA0H/U,EAAAA,EAAAA;;;;MAyBhI,SAASgV,GAAiC9U,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0F2U,GAA+B5U,EAClI,CAIC,MAAM8U,GAAmIjV,EAAAA,EAAAA;;;;MAwBzI,SAASkV,GAAoChV,GAC5C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgG6U,GAAkC9U,EAC3I,CAIC,MAAMgV,GAAgInV,EAAAA,EAAAA;;;;MAuBtI,SAASoV,GAAkClV,GAC1C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAyF+U,GAAmChV,EACrI,CAgBC,MAAMkV,GAAoHrV,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqD1H,SAASsV,GAA8BpV,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiFiV,GAA+BlV,EACzH,CAgBC,MAAMoV,GAAiHvV,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+CvH,SAASwV,GAA6BtV,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA+EmV,GAA8BpV,EACtH,CAgBC,MAAMsV,GAA2GzV,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6CjH,SAAS0V,GAA2BxV,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2EqV,GAA4BtV,EAChH,CAgBkHH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;MA0DNA,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAmD6CA,EAAAA,EAAAA;;;;;;;;;;;;;MA6CAA,EAAAA,EAAAA;;;;;;;;;;;;;MA6CkBA,EAAAA,EAAAA;;;;;;MAkCzDA,EAAAA,EAAAA;;;;;;MAiCfA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0GSA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0F8BA,EAAAA,EAAAA;;;;;;;;;;MAuCAA,EAAAA,EAAAA;;;;;;MAiClBA,EAAAA,EAAAA;;;;;;;;;;;;MAyCvH,MAAM2V,GAA0H3V,EAAAA,EAAAA;;;;MAwBhI,SAAS4V,GAAiC1V,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0FuV,GAA+BxV,EAClI,CAIC,MAAM0V,GAAuH7V,EAAAA,EAAAA;;;;MAyB7H,SAAS8V,GAAgC5V,GACxC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAwFyV,GAA8B1V,EAC/H,CAIC,MAAM4V,GAAkJ/V,EAAAA,EAAAA;;;;;;;;;;;MAkCxJ,SAASgW,GAAyC9V,GACjD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0G2V,GAAuC5V,EAC1J,CAIC,MAAM8V,GAA2GjW,EAAAA,EAAAA;;;;;;;;;;;MAkCjH,SAASkW,GAA4BhW,GACpC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgF6V,GAA0B9V,EACnH,CAIC,MAAMgW,GAAgInW,EAAAA,EAAAA;;;;;;;;;;;;MAoCtI,SAASoW,GAAmClW,GAC3C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8F+V,GAAiChW,EACxI,CAIgGH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;MAqDNA,EAAAA,EAAAA;;;;;;;;;;;;;MA+CkBA,EAAAA,EAAAA;;;;;;;;MAoC3G,MAAMqW,GAA4FrW,EAAAA,EAAAA;;;;;;;;;;;;;MAsClG,SAASsW,GAAuBpW,GAC/B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsEiW,GAAqBlW,EACpG,CAIC,MAAMoW,GAA8GvW,EAAAA,EAAAA;;;;;;;;;;;;MAoCpH,SAASwW,GAA6BtW,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkFmW,GAA2BpW,EACtH,CAIC,MAAMsW,GAAyFzW,EAAAA,EAAAA;;;;;;MA4B/F,SAAS0W,GAAsBxW,GAC9B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoEqW,GAAoBtW,EACjG,CAIyJH,EAAAA,EAAAA;;;;;;;;MAmCTA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4FkBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;MA2DnDA,EAAAA,EAAAA;;;;MAgC9G,MAAM2W,GAAkG3W,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgDxG,SAAS4W,GAAwB1W,GAChC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAqEuW,GAAyBxW,EACvG,CAgBC,MAAM0W,GAA8G7W,EAAAA,EAAAA;;;;;;;;MA8BpH,SAAS8W,GAA6B5W,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkFyW,GAA2B1W,EACtH,CAIC,MAAM4W,GAA8G/W,EAAAA,EAAAA;;;;MAwBpH,SAASgX,GAA6B9W,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkF2W,GAA2B5W,EACtH,CAIC,MAAM8W,GAAuHjX,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;MAgD7H,SAASkX,GAA+BhX,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmF6W,GAAgC9W,EAC5H,CAgBC,MAAMgX,GAAyInX,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuD/I,SAASoX,GAAyClX,GAC/C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAmG+W,GAAsChX,EAClJ,CAYD,MAAMkX,GAAuHrX,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwF7H,SAASsX,GAA+BpX,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmFiX,GAAgClX,EAC5H,CAgBC,MAAMoX,GAAoHvX,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgF1H,SAASwX,GAA8BtX,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiFmX,GAA+BpX,EACzH,CAgBC,MAAMsX,GAAoHzX,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgF1H,SAAS0X,GAA8BxX,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiFqX,GAA+BtX,EACzH,CAgBC,MAAMwX,GAAqJ3X,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgF3J,SAAS4X,GAAyC1X,GACjD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuGuX,GAA0CxX,EAC1J,CAgBC,MAAM0X,GAAsF7X,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyD5F,SAAS8X,GAAoB5X,GAC5B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6DyX,GAAqB1X,EAC3F,CAgBC,MAAM4X,GAAwG/X,EAAAA,EAAAA;;;;;;;;MA8B9G,SAASgY,GAA2B9X,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8E2X,GAAyB5X,EAChH,CAI6IH,EAAAA,EAAAA;;;;;;;MAmC5I,MAAMiY,GAAsIjY,EAAAA,EAAAA;;;;;;;;;;;;MAiC5I,SAASkY,GAAqChY,GAC7C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkG6X,GAAmC9X,EAC9I,CAIC,MAAMgY,GAAwGnY,EAAAA,EAAAA;;;;MAwB9G,SAASoY,GAA2BlY,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8E+X,GAAyBhY,EAChH,CAIC,MAAMkY,GAAmIrY,EAAAA,EAAAA;;;;;;;;;;;MA6BzI,SAASsY,GAAmCpY,GAC3C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2FiY,GAAoClY,EACxI,CAgBC,MAAMoY,GAA8GvY,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmJmDA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgHZA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiFZA,EAAAA,EAAAA;;;;;;;;;;MA+C/I,MAAMwY,GAA2JxY,EAAAA,EAAAA;;;;;;;;;;;;;;;;;MAsDNA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;MA0DYA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;MAkEMA,EAAAA,EAAAA;;;;;;;;;MA8CSA,EAAAA,EAAAA;;;;;;;;;;;;;MAiDtL,MAAMyY,GAAmIzY,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MAsDzI,SAAS0Y,GAAoCxY,GAC5C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgGqY,GAAkCtY,EAC3I,CAIwHH,EAAAA,EAAAA;;;;;;;;;;MAsCqBA,EAAAA,EAAAA;;;;MAgCZA,EAAAA,EAAAA;;;;MA+BuCA,EAAAA,EAAAA;;;;;;;MAmCSA,EAAAA,EAAAA;;;;;;;MAmC1CA,EAAAA,EAAAA;;;;;;;;;;;;;MA2CTA,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAgDAA,EAAAA,EAAAA;;;;;;;;;;;;;;;MA+CAA,EAAAA,EAAAA;;;;;;;;;;;;;;;MA+CAA,EAAAA,EAAAA;;;;;;;;;;;;;;;MA+CAA,EAAAA,EAAAA;;;;;;;;;;;;;;MA6CAA,EAAAA,EAAAA;;;;;;;;;;;;;;;MA+CAA,EAAAA,EAAAA;;;;;;;;;;;;;;;MA+CAA,EAAAA,EAAAA;;;;;;;;;;;;;;MA6C2BA,EAAAA,EAAAA;;;;;;MAkCGA,EAAAA,EAAAA;;;;;;;MAmCpCA,EAAAA,EAAAA;;;;;;;;;;;;;;;MA0CTA,EAAAA,EAAAA;;;;;;;;;;;;;MAwCAA,EAAAA,EAAAA;;;;;;;;;;MAqCSA,EAAAA,EAAAA;;;;;;;;MAqCAA,EAAAA,EAAAA;;;;;;;;MAmCTA,EAAAA,EAAAA;;;;;;MAiCwBA,EAAAA,EAAAA;;;;;;;;;;MA+CfA,EAAAA,EAAAA;;;;MA+BSA,EAAAA,EAAAA;;;;MA+BHA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA0DMA,EAAAA,EAAAA;;;;;;;;;;MA8CGA,EAAAA,EAAAA;;;;MA+BSA,EAAAA,EAAAA;;;;MA+BHA,EAAAA,EAAAA;;;;;;;;MAqCSA,EAAAA,EAAAA;;;;;;;;MA6CHA,EAAAA,EAAAA;;;;;;;;;;;;;;;MAoDtDA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiFYA,EAAAA,EAAAA;;;;;;;;;MA8CxG,MAAM2Y,GAAiH3Y,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MAuCvH,SAAS4Y,GAA6B1Y,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA+EuY,GAA8BxY,EACtH,CACC,SAAS0Y,GAAiC3Y,GACvC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAmFuY,GAA8BxY,EAC1H,CAYqIH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;MAgEpCA,EAAAA,EAAAA;;;;;;;;;;;MAuClG,MAAM8Y,GAAqG9Y,EAAAA,EAAAA;;;;;;;;;;;MAkC3G,SAAS+Y,GAA0B7Y,GAClC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4E0Y,GAAwB3Y,EAC7G,CAIC,MAAM6Y,GAAyIhZ,EAAAA,EAAAA;;;;;;;;;MA8B/I,SAASiZ,GAAsC/Y,GAC9C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoG4Y,GAAoC7Y,EACjJ,CAIgJH,EAAAA,EAAAA;;;;;;;;;MAuC3BA,EAAAA,EAAAA;;;;;;MAkCpH,MAAMkZ,GAA0HlZ,EAAAA,EAAAA;;;;MAuBhI,SAASmZ,GAAiCjZ,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0F8Y,GAA+B/Y,EAClI,CAI8HH,EAAAA,EAAAA;;;;MA+BqBA,EAAAA,EAAAA;;;;MAgCpCA,EAAAA,EAAAA;;;;;;;;;;;;;;;MAqDZA,EAAAA,EAAAA;;;;;;;;;MA8CkBA,EAAAA,EAAAA;;;;;;;MA4C8BA,EAAAA,EAAAA;;;;;;;;;;;;;;MAqDlJ,MAAMoZ,GAA4IpZ,EAAAA,EAAAA;;;;;;;;;MA2BlJ,SAASqZ,GAAsCnZ,GAC9C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiGgZ,GAAuCjZ,EACjJ,CAgB+GH,EAAAA,EAAAA;;;;;;;;;;MAuCAA,EAAAA,EAAAA;;;;;;;;;;;MAyCAA,EAAAA,EAAAA;;;;;;MAiC9G,MAAMsZ,GAAwGtZ,EAAAA,EAAAA;;;;;;MA4B9G,SAASuZ,GAA8BrZ,GACpC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA6EkZ,GAA2BnZ,EACjH,CAYD,MAAMqZ,GAAkGxZ,EAAAA,EAAAA;;;;MAwClGyZ,GAA4FzZ,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAkClG,SAAS0Z,GAAsBxZ,GAC9B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiEqZ,GAAuBtZ,EACjG,CAgBgGH,EAAAA,EAAAA;;;;;;;;;;;MAiDMA,EAAAA,EAAAA;;;;;;;;;;;;;;MA4CrG,MAAM2Z,GAA+I3Z,EAAAA,EAAAA;;;;MAwBrJ,SAAS4Z,GAAwC1Z,GAChD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAwGuZ,GAAsCxZ,EACvJ,CAIC,MAAM0Z,GAAmI7Z,EAAAA,EAAAA;;;;;;;;MA8BzI,SAAS8Z,GAAoC5Z,GAC5C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgGyZ,GAAkC1Z,EAC3I,CAI+GH,EAAAA,EAAAA;;;;;;MAiC9G,MAAM+Z,GAA+F/Z,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAmCrG,SAASga,GAAuB9Z,GAC/B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAmE2Z,GAAwB5Z,EACpG,CAgBwHH,EAAAA,EAAAA;;;;MA0C2BA,EAAAA,EAAAA;;;;;;MA2ChDA,EAAAA,EAAAA;;;;;;;;;MA8CwBA,EAAAA,EAAAA;;;;;;;;;;;;;;MA6C1H,MAAMia,GAAkGja,EAAAA,EAAAA;;;;MA+BlGka,GAA2Gla,EAAAA,EAAAA;;;;;;;MAmC3Gma,GAAiHna,EAAAA,EAAAA;;;;;;;MAkCZA,EAAAA,EAAAA;;;;;;;MA4CkBA,EAAAA,EAAAA;;;;;;;;MAqC7H,MAAMoa,GAA8Gpa,EAAAA,EAAAA;;;;;;;;MA8BpH,SAASqa,GAA6Bna,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkFga,GAA2Bja,EACtH,CAIC,MAAMma,GAAsIta,EAAAA,EAAAA;;;;;;;;;MAgC5I,SAASua,GAAqCra,GAC7C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkGka,GAAmCna,EAC9I,CAIC,MAAMqa,GAA8Gxa,EAAAA,EAAAA;;;;;;MA4BpH,SAASya,GAAgCva,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAiFoa,GAA6Bra,EACvH,CAYwFH,EAAAA,EAAAA;;;;MAyCzF,MAAM0a,GAAmI1a,EAAAA,EAAAA;;;;;;;;;;MAkCzI,SAAS2a,GAAoCza,GAC5C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAgGsa,GAAkCva,EAC3I,CAIwHH,EAAAA,EAAAA;;;;MAgCNA,EAAAA,EAAAA;;;;MAgCGA,EAAAA,EAAAA;;;;;;;;;;;;;;MA2CMA,EAAAA,EAAAA;;;;MAyClBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;MA2D8BA,EAAAA,EAAAA;;;;;;;MAmCAA,EAAAA,EAAAA;;;;;;;MAmCqBA,EAAAA,EAAAA;;;;;;;;;;MAyCMA,EAAAA,EAAAA;;;;MA+BxBA,EAAAA,EAAAA;;;;;;;;;;;MAgDeA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;MAwDxJ,MAAM4a,GAA6H5a,EAAAA,EAAAA;;;;;;;;;;;;MA+BnI,SAAS6a,GAAiC3a,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuFwa,GAAkCza,EAClI,CAgBC,MAAM2a,GAAmI9a,EAAAA,EAAAA;;;;MA+BnI+a,GAAoH/a,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoE1H,SAASgb,GAA8B9a,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiF2a,GAA+B5a,EACzH,CAgB4GH,EAAAA,EAAAA;;;;MAyCGA,EAAAA,EAAAA;;;;MAyCoCA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6EMA,EAAAA,EAAAA;;;;;;;;;;;MAgDxBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwGAA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;MAyDhI,MAAMib,GAAwJjb,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;MA4C9J,SAASkb,GAA0Chb,GAClD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAyG6a,GAA2C9a,EAC7J,CAgB8HH,EAAAA,EAAAA;;;;;;;;;;;;;;;MAoDHA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqKfA,EAAAA,EAAAA;;;;;;;;;;;;MAwCTA,EAAAA,EAAAA;;;;MA+ByDA,EAAAA,EAAAA;;;;;;;;;;;;MAyC1CA,EAAAA,EAAAA;;;;;;;;;;;;MAyCTA,EAAAA,EAAAA;;;;;;;;;;MAuCTA,EAAAA,EAAAA;;;;;;;;MAmCqBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAmEpH,MAAMmb,GAAiHnb,EAAAA,EAAAA;;;;;;;;;;;;;;MAoCvH,SAASob,GAA8Blb,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAoF+a,GAA4Bhb,EACzH,CAI4GH,EAAAA,EAAAA;;;;;;;;MAmCYA,EAAAA,EAAAA;;;;;;;;;MA8CfA,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAiDHA,EAAAA,EAAAA;;;;;;;;;;MAuCkEA,EAAAA,EAAAA;;;;;;;MAmCpCA,EAAAA,EAAAA;;;;MAgCjCA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;MAsDHA,EAAAA,EAAAA;;;;MA+BYA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA0EsDA,EAAAA,EAAAA;;;;MA+B7CA,EAAAA,EAAAA;;;;;;;;MA+CrBA,EAAAA,EAAAA;;;;;;;;;;;;MAiDkBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4ESA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA2DZA,EAAAA,EAAAA;;;;;;;;;MAuCGA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsFkBA,EAAAA,EAAAA;;;;;;;MA4CnI,MAAMqb,GAAsIrb,EAAAA,EAAAA;;;;;;;MA4B5I,SAASsb,GAAqCpb,GAC7C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkGib,GAAmClb,EAC9I,CAI6FH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;MA+D5F,MAAMub,GAAwGvb,EAAAA,EAAAA;;;;;;;;MA4B9G,SAASwb,GAA0Btb,GAClC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAyEmb,GAA2Bpb,EAC7G,CAgBC,MAAMsb,GAA8Gzb,EAAAA,EAAAA;;;;MA0BpH,SAAS0b,GAA6Bxb,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkFqb,GAA2Btb,EACtH,CAIgGH,EAAAA,EAAAA;;;;;;;;;;;MAgD/F,MAAM2b,GAAkG3b,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;MAiElG4b,GAA2G5b,EAAAA,EAAAA;;;;;;;MAyBjH,SAAS6b,GAA2B3b,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2Ewb,GAA4Bzb,EAChH,CAgBC,MAAM2b,GAA8G9b,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;MAsCpH,SAAS+b,GAA4B7b,GACpC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6E0b,GAA6B3b,EACnH,CAgB6IH,EAAAA,EAAAA;;;;;;;;;;;;;;MAmD5I,MAAMgc,GAAmIhc,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAoCzI,SAASic,GAAmC/b,GAC3C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2F4b,GAAoC7b,EACxI,CAgByJH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2GZA,EAAAA,EAAAA;;;;;;;;;;;;;MAkDZA,EAAAA,EAAAA;;;;MA+BAA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAudhI,MAAMkc,GAAgFlc,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoEtF,SAASmc,GAAkBjc,GAC1B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAyD8b,GAAmB/b,EACrF,CAgBC,MAAMic,GAA6Hpc,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuDnI,SAASqc,GAAiCnc,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuFgc,GAAkCjc,EAClI,CAgBC,MAAMmc,GAA8Gtc,EAAAA,EAAAA;;;;;;;MA4BpH,SAASuc,GAA6Brc,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkFkc,GAA2Bnc,EACtH,CAI8HH,EAAAA,EAAAA;;;;;;;;;;;;MAiDlBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;MAwDNA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuGTA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwGwBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;MAmDNA,EAAAA,EAAAA;;;;;;;;;;;;;MA6C6CA,EAAAA,EAAAA;;;;;;;;;;;;;MA6CAA,EAAAA,EAAAA;;;;;;;;;;;;;MA6CkBA,EAAAA,EAAAA;;;;;;MAkCzDA,EAAAA,EAAAA;;;;;;MAiCMA,EAAAA,EAAAA;;;;;;;;MAqCSA,EAAAA,EAAAA;;;;;;MAiCwBA,EAAAA,EAAAA;;;;;;MAkCvCA,EAAAA,EAAAA;;;;;;MAkCqBA,EAAAA,EAAAA;;;;;;MAmCuCA,EAAAA,EAAAA;;;;;;;;MAmChL,MAAMwc,GAAyIxc,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;MAsC/I,SAASyc,GAAqCvc,GAC7C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA+Foc,GAAsCrc,EAC9I,CAgBC,MAAMuc,GAA+I1c,EAAAA,EAAAA;;;;;;;;MA8BrJ,SAAS2c,GAAwCzc,GAChD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAwGsc,GAAsCvc,EACvJ,CAIC,MAAMyc,GAA4I5c,EAAAA,EAAAA;;;;;;;;;MAgClJ,SAAS6c,GAAuC3c,GAC/C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsGwc,GAAqCzc,EACpJ,CAIC,MAAM2c,GAA0H9c,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;MAyChI,SAAS+c,GAAgC7c,GACxC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAqF0c,GAAiC3c,EAC/H,CAgBC,MAAM6c,GAAmIhd,EAAAA,EAAAA;;;;;;MAwBzI,SAASid,GAAmC/c,GAC3C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2F4c,GAAoC7c,EACxI,CAgBC,MAAM+c,GAAqGld,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgF3G,SAASmd,GAAyBjd,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuE8c,GAA0B/c,EAC1G,CAgBC,MAAMid,GAA6Hpd,EAAAA,EAAAA;;;;MAyBnI,SAASqd,GAAkCnd,GAC1C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4Fgd,GAAgCjd,EACrI,CAIC,MAAMmd,GAA0Htd,EAAAA,EAAAA;;;;MAwBhI,SAASud,GAAiCrd,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0Fkd,GAA+Bnd,EAClI,CAIC,MAAMqd,GAAuKxd,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAoC7K,SAASyd,GAAgDvd,GACxD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAwHod,GAA8Crd,EAC/K,CAIC,MAAMud,GAAiK1d,EAAAA,EAAAA;;;;;;;;;;;;;;;;;MAoCvK,SAAS2d,GAA6Czd,GACrD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA+Gsd,GAA8Cvd,EACtK,CAgBC,MAAMyd,GAAyI5d,EAAAA,EAAAA;;;;;;;;;;;;MA+B/I,SAAS6d,GAAqC3d,GAC7C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA+Fwd,GAAsCzd,EAC9I,CAgBC,MAAM2d,GAA+I9d,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;MA4CrJ,SAAS+d,GAAwC7d,GAChD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAwG0d,GAAsC3d,EACvJ,CAIC,MAAM6d,GAAqGhe,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAsD3G,SAASie,GAAyB/d,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuE4d,GAA0B7d,EAC1G,CAgBC,MAAM+d,GAAgFle,EAAAA,EAAAA;;;;;;;;;MAgCtF,SAASme,GAAmBje,GAC3B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8D8d,GAAiB/d,EACxF,CAIC,MAAMie,GAAwGpe,EAAAA,EAAAA;;;;;;;;;;;;;;;;MA4C9G,SAASqe,GAA2Bne,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA8Ege,GAAyBje,EAChH,CAIC,MAAMme,GAAsFte,EAAAA,EAAAA;;;;MAwB5F,SAASue,GAAqBre,GAC7B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkEke,GAAmBne,EAC9F,CAI6FH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;MA6DYA,EAAAA,EAAAA;;;;;;;MA8CfA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkHeA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+EGA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyGkBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;MA0DYA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4GjCA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuKxG,MAAMwe,GAAuHxe,EAAAA,EAAAA;;;;MAwB7H,SAASye,GAAgCve,GACxC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAwFoe,GAA8Bre,EAC/H,CAIC,MAAMue,GAA0H1e,EAAAA,EAAAA;;;;MAwBhI,SAAS2e,GAAiCze,GACzC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0Fse,GAA+Bve,EAClI,CAIC,MAAMye,GAA6H5e,EAAAA,EAAAA;;;;;;;MA4BnI,SAAS6e,GAAkC3e,GAC1C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA4Fwe,GAAgCze,EACrI,CAIC,MAAM2e,GAAkG9e,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAkCxG,SAAS+e,GAAwB7e,GAChC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAqE0e,GAAyB3e,EACvG,CAgBC,MAAM6e,GAAqGhf,EAAAA,EAAAA;;;;;;;;;;;;;;;;MAkC3G,SAASif,GAAyB/e,GACjC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAuE4e,GAA0B7e,EAC1G,CAgB0IH,EAAAA,EAAAA;;;;;;;;;;;;;;;MA+CNA,EAAAA,EAAAA;;;;;;;;;;;;;;;MA+CMA,EAAAA,EAAAA;;;;;;MAiCqBA,EAAAA,EAAAA;;;;;;;;;MAqCrBA,EAAAA,EAAAA;;;;;;;;;MAqCuCA,EAAAA,EAAAA;;;;;;;;;MAqCjCA,EAAAA,EAAAA;;;;;;;;;;MAuClBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyHYA,EAAAA,EAAAA;;;;;;;;MAoCNA,EAAAA,EAAAA;;;;;;;;MAoCMA,EAAAA,EAAAA;;;;;;MAiCwBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiEvCA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2EuCA,EAAAA,EAAAA;;;;;;;;;;;MAyCMA,EAAAA,EAAAA;;;;;;;;;MAiDNA,EAAAA,EAAAA;;;;;;;;;MAqCrBA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;MA0D5I,MAAMkf,GAA2Glf,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;MAwCjH,SAASmf,GAA2Bjf,GACnC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA2E8e,GAA4B/e,EAChH,CAgBC,MAAMif,GAAsFpf,EAAAA,EAAAA;;;;;;;;;;;;MA8B5F,SAASqf,GAAoBnf,GAC5B,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6Dgf,GAAqBjf,EAC3F,CAgBC,MAAMmf,GAA8Gtf,EAAAA,EAAAA;;;;;;;;;;MAkCpH,SAASuf,GAA6Brf,GACrC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAkFkf,GAA2Bnf,EACtH,CAIC,MAAMqf,GAAuHxf,EAAAA,EAAAA;;;;;;;MA4B7H,SAASyf,GAAgCvf,GACxC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAwFof,GAA8Brf,EAC/H,CAIC,MAAMuf,GAAqJ1f,EAAAA,EAAAA;;;;MAgCrJ2f,GAAsI3f,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoD5I,SAAS4f,GAAoC1f,GAC5C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAA6Fuf,GAAqCxf,EAC3I,CAgBC,MAAM0f,GAAkJ7f,EAAAA,EAAAA;;;;;;;;MA8BxJ,SAAS8f,GAAyC5f,GACjD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0Gyf,GAAuC1f,EAC1J,CAIC,MAAM4f,GAA4I/f,EAAAA,EAAAA;;;;;;;;MA8BlJ,SAASggB,GAAuC9f,GAC/C,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAAsG2f,GAAqC5f,EACpJ,CAIC,MAAM8f,GAAkJjgB,EAAAA,EAAAA;;;;MAwBxJ,SAASkgB,GAAyChgB,GACjD,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,EAA0G6f,GAAuC9f,EAC1J,CAI6IH,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqF5I,MAAMmgB,GAAoHngB,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoF1H,SAASogB,GAA8BlgB,GACtC,MAAMC,EAAU,IAAI/jB,KAAmB8jB,GACvC,OAAOE,EAAAA,GAAiF+f,GAA+BhgB,EACzH,CAgBqHH,EAAAA,EAAAA;;;;;;;;;;;MAkDSA,EAAAA,EAAAA;;;;;;;;;;;;;;;;;;;;;;45CC766CpI,IAAIqgB,EAAuC,KA0B3C,SAASC,EAAuCC,GAC/C,IAAKA,EAAMA,MACV,MAAyC,WAArCC,EAAAA,EAAAA,OAAiBC,iBACpBC,QAAQC,MAAM,CAAC,qBAAsBJ,IACrCK,MAAM,wCAENF,QAAQG,MAAM,uBAAuBN,KAE/BO,QAAQC,OAAO,sBAIvB,MAAMC,EAA4B,qBAAhBT,EAAMA,MA3DzB,WACC,MAAMU,EAAe,IAAIC,gBAAgBC,OAAOC,SAASC,QAEzD,MAAO,CACNC,WAAYL,EAAaM,IAAI,cAC7BC,SAAUP,EAAaM,IAAI,YAC3BE,WAAYR,EAAaM,IAAI,cAC7BG,YAAaT,EAAaM,IAAI,eAC9BI,aAAcV,EAAaM,IAAI,gBAC/BK,gBAAiBX,EAAaM,IAAI,mBAClCM,cAAeZ,EAAaM,IAAI,iBAChCO,gBAAiBb,EAAaM,IAAI,mBAClCQ,iBAAkBd,EAAaM,IAAI,oBACnCS,kBAAmBf,EAAaM,IAAI,qBACpCU,aAAchB,EAAaM,IAAI,gBAC/BW,aAAcjB,EAAaM,IAAI,gBAC/BY,WAAYlB,EAAaM,IAAI,cAE/B,CAyCwDa,GAAoB,CAAC,EAGtEC,GADa7B,EAAAA,EAAAA,OACU8B,aAAe,UAG5C,IAAIC,EAA+B,CAClCC,WAAY,UACZC,YAAY,IAAIC,MAAOC,cACvBC,SAAUC,SAASD,SACnBE,IAAK3B,OAAOC,SAAS2B,KACrBC,WAAY7B,OAAO8B,WAAWC,gBAAkB,KAChDC,gBAAiBd,KACd9B,KACAS,GAIJ,MAAiB,YAAbqB,IACHE,EAAgB,IACZA,EACHa,MAAO7C,EAAM6C,OAASC,EAAAA,EAAYC,WAAWC,eAAiB,GAC9DC,QAASjD,EAAMiD,SAAWH,EAAAA,EAAYC,WAAWG,kBAAkBD,SAAW,KAI5ErC,OAAO,YACVT,QAAQgD,IAAI,UAAWnB,EAAchC,MAAO,KAAM,cAAegC,EAAcC,WAAY,KAAM,CAChGmB,KAAMpB,IA/DD,IAAIzB,SAAQ,CAAC8C,EAAS7C,KAE1BV,GACiC,IAAlCA,EAAmBwD,YACe,IAAlCxD,EAAmBwD,WAQyB,IAAlCxD,EAAmBwD,WAC7BxD,EAAmByD,iBAAiB,QAAQ,IAAMF,EAAQvD,KACd,IAAlCA,EAAmBwD,WAC7BD,EAAQvD,GAERU,EAAO,mCAXPV,EAAqB,IAAI0D,UACxB,GAAgC,UAA7B5C,OAAOC,SAAS4C,SAAuB,KAAO,WAAW7C,OAAOC,SAAS6C,oBAE7E5D,EAAmB6D,QAAUxD,QAAQyD,KACrC9D,EAAmB+D,QAAU1D,QAAQyD,KACrC9D,EAAmByD,iBAAiB,QAAQ,IAAMF,EAAQvD,KAMnB,IAmDvCgE,MAAMC,IACNA,EAAGC,KAAKC,KAAKC,UAAUlC,GAAc,IAErCmC,MAAMhE,QAAQyD,KACjB,C,y1CC/LMQ,EAAY,CACjBC,GAAI,CAAEC,I,knFAAKC,G,m+DAAIC,GAAAA,EAAIC,GAAAA,IAGb,SAASC,IACfC,EAAAA,GAAAA,KAAU,CACTP,UAAAA,EACAQ,IAAK,KACLC,UAAW,KACXC,OAAO,GAET,CAEO,SAASC,EAAavpC,GAC5B,MAAMwpC,EAAUlC,EAAAA,EAAYC,WAAWG,iBACjC+B,EAA8B,QAAlBD,GAASE,KAAiB,MAAQF,GAAS/B,SAASkC,uBAAyB,GAC/F,OAAOR,EAAAA,GAAAA,EAAOnpC,EAAgB,CAAE4pC,GAAIH,GACrC,C,qwDChBA,MAAMI,EAAyB,IAEzBC,EAAUC,EAAAA,GAAkB,CACjCC,SAAS,EACTC,UAAW,iBAQNC,EAAQ,EAAGC,WAAAA,EAAYC,cAAAA,MAC5B,MAAMC,GAAUC,EAAAA,EAAAA,IAAWP,EAAAA,GAAe,IACtCI,EACHI,OAAQH,IAEHI,EAAMT,EAAAA,GAAcM,EAASI,EAAAA,IAG7BC,GAAoBC,EAAAA,EAAAA,UAAQ,KAM1B,CAAEC,OADaC,EAAAA,EAAUC,SAASN,EAAIO,YAJ9B,CACdC,aAAc,CAAC,IAAK,IAAK,KAAM,SAAU,QAAS,OAClDC,aAAc,QAIb,CAACT,EAAIO,cAER,OACCnsC,EAAAA,cAAC,OAAIc,UCrCqF,yCDqC/C8qC,EAAIU,eAAgB,YAAU,mBACxEtsC,EAAAA,cAAC,UAAQ4rC,EAAIW,wBACbvsC,EAAAA,cAAC,QAAM4rC,EAAIY,sBAAuBC,wBAAyBX,IAC3D9rC,EAAAA,cAAC0sC,EAAAA,GAAA,CACA,YAAU,uBACVC,KAAMC,EAAAA,GAAaC,MACnBrsC,QAAQ,WACRssC,KAAK,QACLzrC,QAASuqC,EAAImB,UAGd/sC,EAAAA,cAAC,UAAQ4rC,EAAIoB,uBACd,EAIIC,EAAU,KACf,MAAMxB,GAAUC,EAAAA,EAAAA,IAAWP,EAAAA,GAAY+B,QAAS,CAC/CC,IAAIC,EAAAA,EAAAA,SACJC,MAAOnC,IAEFU,EAAMT,EAAAA,GAAYmC,QAAQ7B,EAASI,EAAAA,IACzC,OACC7rC,EAAAA,cAAC,UAAQ4rC,EAAI2B,gBAAiBzsC,UC5DG,yCD6D/B8qC,EAAI4B,YAAYC,KAAKlC,GACrBvrC,EAAAA,cAACsrC,EAAA,CAAMoC,IAAKnC,EAAW4B,GAAI5B,WAAYA,EAAYC,cAAeC,MAEpE,EAIIkC,EAAgBR,IACrBS,gBAAe,KACd1C,EAAQ6B,QAAQI,EAAE,GAClB,EAGIU,EAAa,CAACC,EAAiBC,EAAmB9C,KACvD2C,gBAAe,KACd1C,EAAQ8C,OAAO,CACdC,MAAO,KACP9B,YAAa2B,EACbC,SAAAA,EACAjD,KAAM,SACN,GACD,EAGIoD,EAAe,CAACJ,EAAiBC,EAAmB9C,KACzD2C,gBAAe,KACd1C,EAAQ8C,OAAO,CACdC,MAAO,KACP9B,YAAa2B,EACbC,SAAAA,EACAjD,KAAM,WACN,GACD,EAGIqD,EAAY,CAACL,EAAiBC,EAAmB9C,KACtD2C,gBAAe,KACd1C,EAAQ8C,OAAO,CACdC,MAAO,KACP9B,YAAa2B,EACbC,SAAAA,EACAjD,KAAM,QACN,GACD,EAGIsD,EAAW,MACPlD,QAAAA,EAASyC,aAAAA,EAAcE,WAAAA,EAAYK,aAAAA,EAAcC,UAAAA,G,szHE+H3D,MAAMvB,GAAe,CACpByB,IAAAA,EACAC,UAAAA,EACAC,MAAAA,EACAC,WAAAA,EACAC,YAAAA,EACAC,eAAAA,EACAC,MAAAA,EACAC,UAAAA,EACAC,aAAAA,EACAC,WAAAA,EACAC,KAAAA,EACAC,QAAAA,EACAC,UAAAA,EACAC,WAAAA,GACAC,aAAAA,GACAC,gBAAAA,EACAC,QAAAA,EACAxC,MAAAA,EACAyC,QAAAA,EACAC,cAAAA,EACAC,KAAAA,EACAC,WAAAA,EACAvH,SAAAA,EACAwH,YAAAA,EACAC,mBAAAA,EACAC,kBAAAA,EACAC,KAAAA,EACAC,aAAAA,EACAC,SAAAA,EACAC,SAAAA,EACAC,KAAAA,EACAC,WAAAA,EACAC,SAAAA,EACAC,MAAAA,EACAC,QAAAA,EACAC,aAAAA,EACAC,KAAAA,GACAC,KAAAA,GACAC,SAAAA,GACAC,SAAAA,GACAC,OAAAA,GACAC,UAAAA,GACAC,YAAAA,GACAC,KAAAA,GACAC,KAAAA,GACAC,aAAAA,GACAC,kBAAAA,GACAC,QAAAA,GACAxK,OAAAA,GACAyK,cAAAA,GACAC,oBAAAA,GACAC,gBAAAA,GACAC,sBAAAA,GACAC,OAAAA,GACAC,SAAAA,GACAC,eAAAA,GACAC,IAAAA,GACAC,OAAAA,GACA/H,KAAAA,GACAgI,eAAAA,GACAC,cAAAA,GACAC,aAAAA,GACAC,WAAAA,GACAC,WAAAA,GACAC,cAAAA,GACAC,UAAAA,GACAC,mBAAAA,GACAC,kBAAAA,GACAC,aAAAA,GACAC,UAAAA,GACAC,sBAAAA,GACAC,iBAAAA,GACAC,UAAAA,GACAC,SAAAA,GACAC,cAAAA,GACAC,OAAAA,EACAC,KAAAA,EACAC,aAAAA,EACAC,cAAAA,EACAC,KAAAA,EACAC,MAAAA,GACAC,SAAAA,GACAC,WAAAA,EACAC,QAAAA,EACAC,YAAAA,EACAC,YAAAA,EACAC,OAAAA,GACAC,KAAAA,GACAC,SAAAA,GACAC,MAAAA,GACAC,OAAAA,GACAC,UAAAA,EACAC,SAAAA,EACAC,MAAAA,GACAC,SAAAA,GACAC,QAAAA,GACAC,MAAAA,EACAC,KAAAA,GACAC,WAAAA,GACAC,cAAAA,GACAC,aAAAA,GACAC,SAAAA,GACAC,KAAAA,GACAC,OAAAA,GACAC,KAAAA,GACAC,SAAAA,GACAC,KAAAA,GACAC,aAAAA,GACAC,YAAAA,EACAC,KAAAA,GACAC,WAAAA,GACAC,YAAAA,GACAC,WAAAA,GACAC,QAAAA,GACAC,eAAAA,EACAC,oBAAAA,GACAC,sBAAAA,EACAC,KAAAA,EACAC,SAAAA,EACAC,MAAAA,GACAC,IAAAA,GACAC,OAAAA,GACAC,UAAAA,GACAC,KAAAA,GACAC,KAAAA,GACAC,OAAAA,IAGKC,GAAmB,CACxBC,mBAAAA,GACAC,qBAAAA,GACAC,iBAAAA,GACAC,qBAAAA,GACAC,qBAAAA,GACAC,mBAAAA,GACAC,gBAAAA,GACAC,uBAAAA,GACAC,2BAAAA,GACAC,qBAAAA,GACAC,oBAAAA,GACAC,iBAAAA,GACAC,6BAAAA,GACAC,wBAAAA,GACAC,kBAAAA,GACAC,2BAAAA,GACAC,6BAAAA,GACAC,qBAAAA,GACAC,sBAAAA,GACAC,yBAAAA,GACAC,4BAAAA,GACAC,uBAAAA,GACAC,iBAAAA,GACAC,mBAAAA,GACAC,0BAAAA,GACAC,yBAAAA,GACAC,sBAAAA,GACAC,8BAAAA,GACAC,sBAAAA,GACAC,sBAAAA,GACAC,0BAAAA,GACAC,sBAAAA,GACAC,6BAAAA,GACAC,qBAAAA,GACAC,kBAAAA,GACAC,OAAAA,GACAC,WAAAA,GACAC,QAAAA,GACAC,MAAAA,GACAC,MAAAA,IAGKC,GAAsB,CAC3BC,sBAAAA,GACAC,uBAAAA,GACAC,oBAAAA,GACAC,qBAAAA,GACAC,oBAAAA,GACAC,cAAAA,GACAC,qBAAAA,GACAC,eAAAA,GACAC,sBAAAA,GACAC,gBAAAA,GACAC,oBAAAA,GACAC,gBAAAA,GACAC,yBAAAA,GACAC,uBAAAA,GACAC,sBAAAA,GACAC,sBAAAA,GACAC,kBAAAA,GACAC,qBAAAA,GACAC,qBAAAA,GACAC,uBAAAA,GACAC,qBAAAA,GACAC,oBAAAA,GACAC,iBAAAA,GACAC,eAAAA,GACAC,eAAAA,GACAC,sBAAAA,GACAC,mBAAAA,GACAC,gBAAAA,GACAC,iBAAAA,GACAC,oBAAAA,GACAC,sBAAAA,GACAC,gBAAAA,GACAC,gBAAAA,GACAC,gBAAAA,GACAC,oBAAAA,GACAC,gBAAAA,GACAC,gBAAAA,IAGKC,GAAgB,CACrBC,wBAAAA,GACAC,YAAAA,GACAC,aAAAA,GACAC,aAAAA,GACAC,cAAAA,GACAC,aAAAA,GACAC,yBAAAA,GACAC,eAAAA,GACAC,kBAAAA,GACAC,sBAAAA,IAGKC,GAAQ,CACbC,SAAAA,G,+3BCvcWC,E,wFAAAA,IAAAA,EAAAA,GAAA,IACXC,KAAO,OACPD,EAAAE,eAAiB,iBACjBF,EAAAG,SAAW,WAHAH,GAmBZ,MAAMI,GAAiB/N,EAAAA,EAAAA,IAAAA,EAAoB,MAC1Cb,GAAI,GACJ6O,KAAM,GACNC,MAAO,GACPC,gBAAgB,EAChBC,cAAc,EACdC,iBAAkB,OAClBC,uBAAuB,EACvBC,6BAA6B,MA6DxBC,GAAevO,EAAAA,EAAAA,IAAAA,EAAyB,MAC7CwO,eAAgB,EAChBC,aAAc,MAkBTC,GAAqB1O,EAAAA,EAAAA,IAAAA,EAC1B2O,EAAAA,EAAAA,KACEC,IAAAA,CACAC,aAAc,GACdC,gBAAkBC,GAAiBH,EAAI,CAAEC,aAAcE,IACvDC,2BAA2B,EAC3BC,6BAA+BC,GAAcN,EAAI,CAAEI,0BAA2BE,IAC9EC,SAAU,OACVC,YAAcC,GAAST,EAAI,CAAEO,SAAUE,OAExC,CACCrB,KAAM,mCAUHsB,GAA0BtP,EAAAA,EAAAA,IAA8B4O,IAAAA,CAC7DW,YAAY,EACZC,cAAgBC,GAAkBb,EAAI,CAAEW,WAAYE,QAG/CC,EA7DN,WACC,MAAMC,EAAKzV,SAAS0V,eAAe,kBACnC,IAAKD,EAAI,OAAO,KAEhB,MAAME,EAAMF,EAAGG,aAAaC,QAAU,GACtC,IACC,MAAMC,EAZR,SAA0BH,EAAanQ,GAGtC,OAFcmQ,EAAII,MAAM,YAAYxQ,KAAKyQ,GAAMC,SAASD,EAAG,OAAQ,IACxCzQ,KAAI,CAAC2Q,EAAMC,IAAMC,OAAOC,aAAaH,EAAO1Q,EAAI8Q,WAAWH,EAAI3Q,OACtE+Q,KAAK,GAC1B,CAQeC,CAAiBb,EAdR,cAgBtB,OADgBhU,KAAK8U,MAAMX,EAE5B,CAAC,MAAQY,GACR,OAAA7Y,QAAQG,MAAM,gCAAiC0Y,GACxC,IACR,CACD,CAgDmBC,GACbhZ,EAAgB,IACd6X,EAGFoB,EAAuB,KAC5B,GAAmB,OAAfpB,EACH,OAGD,MAAMqB,EAAoBrB,EAAWsB,mBACX,OAAtBD,GACHhD,EAAekD,UAAS,IAAMF,IAAmB,GAGlD,IACC,MAAMG,EAAW,IAAIC,EAAAA,EAAS,CAC7BC,QAAS,CACR,cAAe1B,EAAW2B,YAE3BC,IAAK,GAAG5B,EAAW6B,0BACnBC,MAAOC,MAAOH,EAAK95B,KAClB,MAAMk6B,QAAiBF,MAAMF,EAAK95B,GAClC,GAAIk6B,EAASN,QAAQxY,IAAI,sBACxB,MAAAb,QAAQ2E,MAAM,6CACdlE,OAAOC,SAASkZ,SACV,IAAIx4C,MAAM,sDAEjB,OAAOu4C,KAGHE,EAAc,IAAIC,EAAAA,EAAc,CACrCC,aAAc,CACbC,MAAO,CACNC,OAAQ,CACPC,aAAc,CACbC,OAAO,KASVC,UAAW,CACVC,WAAW,GAEZC,SAAU,CACTD,WAAW,GAEZE,uBAAwB,CACvBF,WAAW,GAEZG,gBAAiB,CAChBH,WAAW,GAEZI,uBAAwB,CACvBJ,WAAW,GAEZ/+B,YAAa,CACZ++B,WAAW,GAEZK,kBAAmB,CAClBL,WAAW,GAEZM,uBAAwB,CACvBN,WAAW,GAEZO,qBAAsB,CACrBP,WAAW,GAEZQ,6BAA8B,CAC7BR,WAAW,GAEZS,oCAAqC,CACpCT,WAAW,MAIRU,EAA0C,CAC/CC,UAAWrD,EAAW2B,WACtB2B,aAAc,IAAIC,EAAAA,EAAa,CAC9BC,KAAMhC,EACNiC,MAAOvB,IAERpD,eAAgB,GAChBC,aAAc,GAEfF,EAAa0C,SAAS6B,GAAyB,GAC/CM,EAAAA,EAAMC,SAASC,eAAiB,YAChCF,EAAAA,EAAMC,SAASE,eAAiB,cAChCH,EAAAA,EAAMC,SAASG,eAAgB,CAChC,CAAC,MAAQtb,GACRH,QAAQG,MAAM,kCAAmCA,EAClD,CAEIwX,EAAW+D,UACd/Y,EAAAA,EAAYC,WAAW+Y,WAAWhE,EAAW+D,UAG9C,MAAME,EAAS5F,EAAepT,YAAYwE,GACtCwU,GACHC,EAAAA,GAAyBjZ,WAAWkZ,IAAIH,WAAWC,IAAgBjE,EAAWoE,mBAAmB,C,6UCnPnG,SAAgB,KAAO,2BAA2B,eAAe,mCAAmC,cAAc,kCAAkC,aAAa,iCAAiC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,eAAe,mCAAmC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,UAAU,8BAA8B,WAAW,+BAA+B,UAAU,8BAA8B,SAAS,6BAA6B,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,YAAY,gCAAgC,WAAW,+BAA+B,UAAU,8BAA8B,YAAY,gCAAgC,WAAW,+BAA+B,UAAU,8BAA8B,YAAY,gCAAgC,WAAW,+BAA+B,UAAU,8BAA8B,YAAY,gCAAgC,WAAW,+BAA+B,UAAU,8BAA8B,YAAY,gCAAgC,WAAW,+BAA+B,UAAU,8BAA8B,YAAY,gCAAgC,WAAW,+BAA+B,UAAU,8BAA8B,YAAY,gCAAgC,WAAW,+BAA+B,UAAU,8BAA8B,YAAY,gCAAgC,WAAW,+BAA+B,UAAU,8BAA8B,YAAY,gCAAgC,WAAW,+BAA+B,UAAU,8BAA8B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,aAAa,iCAAiC,YAAY,gCAAgC,WAAW,+BAA+B,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,cAAc,kCAAkC,aAAa,iCAAiC,YAAY,gCAAgC,qBAAqB,yCAAyC,oBAAoB,wCAAwC,mBAAmB,uCAAuC,qBAAqB,yCAAyC,oBAAoB,wCAAwC,mBAAmB,uCAAuC,kBAAkB,sCAAsC,gBAAgB,oCAAoC,wBAAwB,4CAA4C,sBAAsB,0CAA0C,aAAa,iCAAiC,WAAW,+BAA+B,kBAAkB,sCAAsC,gBAAgB,oCAAoC,gBAAgB,oCAAoC,cAAc,kCAAkC,uBAAuB,2CAA2C,qBAAqB,yCAAyC,eAAe,mCAAmC,aAAa,iCAAiC,cAAc,kCAAkC,YAAY,gCAAgC,eAAe,mCAAmC,aAAa,iCAAiC,cAAc,kCAAkC,YAAY,gCAAgC,mBAAmB,uCAAuC,iBAAiB,qCAAqC,qBAAqB,yCAAyC,mBAAmB,uCAAuC,eAAe,mCAAmC,aAAa,iCAAiC,qBAAqB,yCAAyC,mBAAmB,uCAAuC,yBAAyB,6CAA6C,uBAAuB,2CAA2C,aAAa,iCAAiC,eAAe,mCAAmC,gBAAgB,oCAAoC,cAAc,mCCoC3l7BC,EAAO/hD,EAAAA,YACnB,EAEEgiD,OAAAA,EACAC,UAAAA,EACAC,YAAAA,EACAC,MAAAA,EACAC,OAAAA,EACAtV,KAAAA,EACAuV,OAAAA,EACAvhD,UAAAA,EACAwhD,OAAAA,EACAC,UAAAA,EACAC,aAAAA,EACAC,WAAAA,EACAC,YAAAA,KACG3hD,GAEJ4hD,KAEA,MAAOC,EAASC,IAAcC,EAAAA,EAAAA,UAAS,MACjCC,GAAcC,EAAAA,EAAAA,QAAO,OAG3BC,EAAAA,EAAAA,YAAU,KACJN,IACuB,mBAAjBA,EACVA,EAAaI,EAAYG,SAEzBP,EAAaO,QAAUH,EAAYG,QAAO,GAEzC,CAACP,KAEJM,EAAAA,EAAAA,YAAU,KACTE,GAAU,GACR,CAACnB,IAEJ,MAAMoB,EAAaL,EAEb9hD,GAAaC,EAAAA,EAAAA,GAAK,CACvBC,EAAOwrC,KACPsV,GAAa9gD,EAAO,QAAQ8gD,KAC5BC,GAAe/gD,EAAO,UAAU+gD,KAChCpV,GAAQ3rC,EAAO,QAAQ2rC,KACvBqV,GAAShhD,EAAO,SAASghD,KACzBC,GAAUjhD,EAAO,UAAUihD,KAC3BC,GAAUlhD,EAAO,UAAUkhD,KAC3BC,IAAUe,EAAAA,EAAAA,IAAUf,GACpBC,GAAa,cAAcA,IAC3BC,GAAgB,iBAAiBA,IACjCC,GAAc,eAAeA,IAC7BC,GAAe,gBAAgBA,IAC/B5hD,IA+BKqiD,EAAY,KACjB,GAAKC,EAAWF,QAGhB,GAAIlB,GACH,GAAIY,IAAYZ,EAAQ,CACvBa,EAAWb,GACX,MAAMsB,EAAWtB,EACjBoB,EAAWF,QAAQK,UAAY,GApChBX,KACjB,GAAIpc,OAAOgd,OAAOC,YAAYb,GAC7B,OAAOzc,QAAQ8C,QAAQzC,OAAOgd,MAAMC,UAAUb,IACxC,GAAIpc,OAAOgd,OAAOE,mBAAmBd,GAC3C,OAAOpc,OAAOgd,MAAME,iBAAiBd,GAC/B,CACN,MAAMe,EAAcnE,MAAMoD,GACxBlZ,MAAMgW,GAEe,MAApBA,EAASkE,QACTlE,EAASN,QAAQxY,IAAI,gBAAgBid,WAAW,iBAEzCnE,EAASt+C,OAET+kC,QAAQC,OAAOsZ,KAGvBhW,MAAMoa,IACNtd,OAAOgd,MAAMC,UAAUb,GAAWkB,SAC3Btd,OAAOgd,MAAME,iBAAiBd,GAC9BkB,KAGT,OAAAtd,OAAOgd,MAAME,iBAAiBd,GAAWe,EAClCA,CACR,GAYEI,CAAS/B,GACPtY,MAAMsa,IACN,GAAIV,IAAatB,GAAUoB,EAAWF,QAAS,CAC9CE,EAAWF,QAAQK,UAAYS,EAC/B,MAAMC,EAAWX,EACfY,MAAM,YACNC,MACAC,QAAQ,OAAQ,IACdH,GACHb,EAAWF,QAAQmB,UAAUhW,IAAI4V,EAEnC,KAEAla,OAAO2V,IACP3Z,QAAQG,MAAMwZ,GACV0D,EAAWF,UACdE,EAAWF,QAAQK,UAAY,OAGnC,OAEAH,EAAWF,QAAQK,UAAY,KAIjC,OAAOvjD,EAAAA,cAAC,UAAQe,EAAOD,UAAWG,EAAYD,IAAKoiD,GAAY,IAIjErB,EAAKvgD,YAAc,M,o9BC9JnB8iD,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,E,2gBAOA,MAAQlX,WAAAA,EAAYK,aAAAA,IAAiBE,EAAAA,EAAAA,KAE/B4W,EAAN,MAAMA,UAA2CC,EAAAA,EAAjD,kCACCC,EAAA,KAAAZ,EAAsB,GACtBY,EAAA,KAAAX,EAAwB,KACxBW,EAAA,KAAAV,EAAsB,KAGtB,QAAAW,CAASvf,GACR,GAAwB,IAApBwf,KAAKlc,WACRkc,KAAKlc,WAAa,EAClBkc,KAAK7b,QAAQ3D,QAAK,GAElByf,EAAAD,KAAKd,EAALgB,EAAAF,KAAKd,GAAe,GACpBve,QAAQ2E,MAAM,+BAA+B4a,EAAAF,KAAKd,QAAgB,IAAIvc,MAAOC,gBAAiBpC,GAC1F0f,EAAAF,KAAKd,IAAeU,EAAmCO,YAK1D,OAJAxf,QAAQG,MAAM,2DACd2H,EAAW,kDAAmD,KAC9DuX,KAAKI,aAAa3Y,aAClBuY,KAAKI,aAAe,MAKtB,GAAIJ,KAAKI,cAC6B,IAAjCJ,KAAKI,aAAatc,WAAkB,CAEvCkc,KAAKI,aAAa3Y,QAClBuY,KAAKI,aAAe,KAGpB,MAAMC,EAAUC,KAAKC,MAAML,EAAAF,KAAKb,GAAgBmB,KAAKE,SAAWN,EAAAF,KAAKZ,IACrEY,KAAKS,OAASC,YAAW,IAAMV,KAAKW,UAAUN,EAC/C,CAEF,CAEA,OAAAO,CAAQpgB,GACPG,QAAQ2E,MAAM,wBAAyB9E,EAAOwf,KAAKI,cACnDH,EAAAD,KAAKd,EAAc,GACnB2B,MAAMD,QAAQpgB,EACf,GAtCA0e,EAAA,YACAC,EAAA,YACAC,EAAA,YACA0B,EAJKlB,EAIE,cAAc,IAJtB,IAAMmB,EAANnB,EA0CA,MAAMoB,EAAN,cACClB,EAAA,KAAAT,GACAS,EAAA,KAAAR,EAA6C,IAC7CQ,EAAA,KAAAP,GAA4B,GAE5BuB,EAAA,KAAO,eAAeG,IACrBf,EAAAF,KAAKV,GAAW4B,KAAKD,GACd,IAAMjB,KAAKmB,eAAeF,MAGlCH,EAAA,KAAO,kBAAkBG,IACxBhB,EAAAD,KAAKV,EAAaY,EAAAF,KAAKV,GAAW9R,QAAQ4T,GAAMA,IAAMH,IAAS,IAGhEnB,EAAA,KAAAN,GAAYhG,IACX7Y,QAAQ2E,MAAM,qBAAsBkU,EAAE5V,MACtC,IACC,MAAMpD,EAAQiE,KAAK8U,MAAMC,EAAE5V,MAE3B,GADAjD,QAAQ2E,MAAM,iBAAkB9E,GAC5BA,EAAMM,MAET,YADA2H,EAAWjI,EAAMM,MAAM,SAAc,iBAGtC,GAAIN,EAAM6gB,QAET,YADAvY,EAAatI,EAAM6gB,QAAQ,SAG5B,IAAKnB,EAAAF,KAAKT,GAAkB,CAC3B,MAAM+B,EACLhe,EAAAA,EAAYC,WAAWC,gBAAiB/C,EAAAA,EAAAA,OAAiB8gB,4BAC1D,IAAK/gB,EAAMghB,iBAAmBF,IAAmBA,EAEhD,YADA3gB,QAAQ2E,MAAM,yCAGhB,CACA4a,EAAAF,KAAKV,GAAWmC,SAASL,GAAMA,EAAE5gB,IAClC,CAAC,MAAQkhB,GACR/gB,QAAQyD,KAAK,sCAAuCsd,EAAKlI,EAAE5V,KAC5D,KAGDkc,EAAA,KAAAL,GAAkBjG,IAEjB7Y,QAAQ2E,MAAM,eAAgBkU,EAAC,IAGhCsG,EAAA,KAAAJ,GAAU,KACT/e,QAAQgD,IAAI,sCACZwT,EAAAA,GACE5T,YACCqY,cAAc+F,MAAM,CAAEA,MAAOloB,EAAAA,MAC9B6K,MAAMgW,IACN,GAAKA,EAASsH,OAUb,OAAO7gB,QAAQC,OAAOsZ,IARpBlZ,OAAOygB,qBACRvH,EAAS1W,KAAKke,oBAAqBrhB,EAAAA,EAAAA,OAAiBshB,kBAAoB,MAExE3gB,OAAOygB,qBAAsB,EAC7BzgB,OAAO4gB,MAAMC,SAAQ,IAOvBtd,MAAMhE,QAAQG,MAAK,IAGtBggB,EAAA,KAAO,cAAa,CAACvE,EAAgB2F,GAA2B,KAC/DhC,EAAAF,KAAKL,GAAL,KAAAK,MAGAC,EAAAD,KAAKX,EAAiB,IAAI0B,EAAmC,UAAUxE,OACvE2D,EAAAF,KAAKX,GAAe8C,OAASjC,EAAAF,KAAKN,GAClCQ,EAAAF,KAAKX,GAAelb,QAAU+b,EAAAF,KAAKP,GACnCS,EAAAF,KAAKX,GAAe+C,UAAYlC,EAAAF,KAAKR,GACrCS,EAAAD,KAAKT,EAAmB2C,EAAAA,IAGzBpC,EAAA,KAAAH,GAAW,KACNO,EAAAF,KAAKX,KACRa,EAAAF,KAAKX,GAAe5X,QACpBwY,EAAAD,KAAKX,OAAiB,MAExB,EAnFAA,EAAA,YACAC,EAAA,YACAC,EAAA,YAWAC,EAAA,YA2BAC,EAAA,YAKAC,EAAA,YAiCAC,EAAA,Y,2DCTD,MAAMnD,GAA2B5T,EAAAA,EAAAA,IAAkB4O,IAClD,MAAM6K,EAAW,CAACC,EAAWC,KAC5B/K,GAAKgL,IAAAA,IACDA,EACHC,cAAe,IACXD,EAAMC,cACT,CAACH,GAAYC,OAGfG,EAAqBJ,EAAWC,GAAW,CAAC,EAAC,EAGxC9F,EAAM,IAAIuE,EAChB,OAAAvE,EAAIkG,aAAaniB,IAChB,MAAM8hB,EAAYM,OAAOC,KAAKriB,GAAO,GAC/B+hB,EAAU/hB,EAAM8hB,GACtBD,EAASC,EAAWC,EAAO,IAErB,CAAE9F,IAAAA,EAAKgG,cAAe,CAAC,EAAGJ,SAAAA,EAAS,IAGrCS,GAAUC,EAAAA,EAAAA,KAEVC,EAAsB,CAC3BC,EACAC,KAEA,MAAMC,GAAYvF,EAAAA,EAAAA,SAAO,GACnBwF,EAAmB5G,GACxB6G,EAAAA,EAAAA,IAAYb,GAAUU,EAAU7a,KAAKC,GAAQka,EAAMC,cAAcna,QAG5Dgb,GAAsB1F,EAAAA,EAAAA,QAAsC,KAElEC,EAAAA,EAAAA,YAAU,KACT,IAAKsF,EAAUrF,QAGd,OAFAqF,EAAUrF,SAAU,OACpBwF,EAAoBxF,QAAUsF,GAI/B,QAASnK,EAAI,EAAGA,EAAImK,EAAiBG,OAAQtK,IAAK,CACjD,MAAMsJ,EAAUa,EAAiBnK,GAC3BqJ,EAAYY,EAAUjK,GAC5B,GAAImK,EAAiBnK,KAAOqK,EAAoBxF,QAAQ7E,GAAI,CAC3DgK,EAAOX,EAAWC,GAClB,KACD,CACD,CAEAe,EAAoBxF,QAAUsF,IAC5B,CAACA,EAAkBH,EAAQC,GAAU,EAGzC,SAASM,EACRlB,EACAmB,EACAC,GAEKA,GAAaD,GAIlBX,EAAQa,GAAGrB,EAAWoB,GACtBD,EAASE,GAAG,kBAAkB,KAC7Bb,EAAQc,IAAItB,EAAWoB,EAAQ,KAL/B/iB,QAAQyD,KAAK,6BAOf,CAEA,IAAIyf,EAA6C,KACjD,MACMnB,EAAuB,CAACJ,EAAoCC,KACjE,MAAQzZ,aAAAA,IAAiBE,EAAAA,EAAAA,KACzB,OAAQsZ,GACP,IAAK,uBACAuB,IACHC,aAAaD,GACbA,EAAsB,MAEvBA,EAAsBnD,YAAW,IAAMoC,EAAQiB,KAAKzB,EAAWC,IATvC,KAUxB,MAED,IAAK,2BACJ,IAAKA,EAAQ,MAEZ,YADA5hB,QAAQG,MAAM,4BAGfgI,EAAa,yBAAyByZ,EAAQ,UAAYhd,EAAAA,EAAAA,GAAU,oBACpEud,EAAQiB,KAAK,gBAAiBxB,GAC9B,MAED,IAAK,0BACJ,IAAKA,EAAQ,MAEZ,YADA5hB,QAAQG,MAAM,4BAGVyhB,EAAQ,SACZ5hB,QAAQG,MAAM,yBAEfgI,EAAa,yBAAyByZ,EAAQ,sBAC9CO,EAAQiB,KAAK,mBAAoBxB,EAAQ,SACzC,MAED,IAAK,yBACJ,IAAKA,EAAQ,MAEZ,YADA5hB,QAAQG,MAAM,4BAGVyhB,EAAQ,QACZ5hB,QAAQG,MAAM,wBAEfgI,EAAa,yBAAyByZ,EAAQ,qBAC9CO,EAAQiB,KAAK,kBAAmBxB,EAAQ,QACxC,MAED,IAAK,yBACJ,IAAKA,EAAQ,MAEZ,YADA5hB,QAAQG,MAAM,4BAGVyhB,EAAQ,QACZ5hB,QAAQG,MAAM,wBAEfgI,EAAa,yBAAyByZ,EAAQ,qBAC9CO,EAAQiB,KAAK,kBAAmBxB,EAAQ,QACxC,MAED,IAAK,2BACJ,IAAKA,EAAQ,MAEZ,YADA5hB,QAAQG,MAAM,4BAGfgI,EAAa,yBAAyByZ,EAAQ,UAAYhd,EAAAA,EAAAA,GAAU,oBACpEud,EAAQiB,KAAK,wBACb,MAED,IAAK,oBACJ,IAAKxB,EAAQ,MAEZ,YADA5hB,QAAQG,MAAM,4BAGfgI,EAAa,yBAAyByZ,EAAQ,gBAC9CO,EAAQiB,KAAK,wBACb,MAED,IAAK,2BACJ,IAAKxB,EAAQ,MAEZ,YADA5hB,QAAQG,MAAM,4BAGfgI,EAAa,wBAAwByZ,EAAQ,uBAC7CO,EAAQiB,KAAK,wBACb,MAED,IAAK,sBACJ,IAAKxB,EAAQ,MAEZ,YADA5hB,QAAQG,MAAM,4BAGfgiB,EAAQiB,KAAK,sBACb,MAED,IAAK,8BACmC,GAAxBxB,EAAQ,WAGtBzZ,EAAa,IAAGvD,EAAAA,EAAAA,GAAU,iDAEpBgd,EAAQ,UAEhB,QAECO,EAAQiB,KAAKzB,EAAWC,GAE1B,EAGKyB,EAAuB,CAAC1B,EAAoCC,IACjE/F,EAAyBjZ,WAAW8e,SAASC,EAAWC,E,0zDCrKlD,MAAMrmD,EAActB,EAAAA,YAC1B,EAEEqpD,QAAAA,EACAC,WAAAA,EACAC,cAAAA,EACAC,YAAAA,EACAC,aAAAA,EACAnH,OAAAA,EACAC,UAAAA,EACAC,aAAAA,EACAC,WAAAA,EACAC,YAAAA,EACA5V,KAAAA,EACAsV,OAAAA,EACAD,MAAAA,EACAuH,WAAAA,EACA5oD,UAAAA,EACAS,SAAAA,KACGR,GAEJC,KAEA,MAAMC,GAAaC,EAAAA,EAAAA,GAAK,CACvBJ,EACAgsC,GAAQ6c,EAAQ7c,GAChBwV,GAAUe,EAAUf,GACpBC,GAAa,cAAcA,IAC3BC,GAAgB,iBAAiBA,IACjCC,GAAc,eAAeA,IAC7BC,GAAe,gBAAgBA,IAC/BgH,GAAc,cAAcA,IAC5BL,GAAWO,EAAWP,GACtBC,GAAc,eAAeA,IAC7BC,GAAiB,kBAAkBA,IACnCC,GAAe,gBAAgBA,IAC/BC,GAAgB,iBAAiBA,IACjCrH,GAAU,UAAUA,IACpBD,GAAS,SAASA,MAGnB,OACCniD,EAAAA,cAAC,OAAIgB,IAAKA,KAASD,EAAOD,UAAWG,EAAY4oD,MAAO9oD,EAAM8oD,OAC5DtoD,EACF,IAMH,SAASooD,EAAQ7c,GAChB,OAAIgd,MAAMC,QAAQjd,GACVA,EAAKW,KAAKuc,GAAM,QAAQA,MAAKvL,KAAK,KAEnC,QAAQ3R,GAChB,CAEO,SAAS8c,EAAWP,GAC1B,GAAIS,MAAMC,QAAQV,GACjB,OAAQA,EAAQV,QACf,QACA,KAAK,EACJ,MAAO,WAAWU,IACnB,KAAK,EACJ,MAAO,oBAAoBA,EAAQ,yBAAyBA,EAAQ,KACrE,KAAK,EACJ,MAAO,eAAeA,EAAQ,yBAAyBA,EAAQ,sCAClCA,EAAQ,KACtC,KAAK,EACJ,MAAO,eAAeA,EAAQ,oBAAoBA,EAAQ,sCAC7BA,EAAQ,mBAAmBA,EAAQ,KAInE,MAAO,WAAWA,GACnB,CAEO,SAAShG,EAAUf,GACzB,GAAIwH,MAAMC,QAAQzH,GACjB,OAAQA,EAAOqG,QACd,QACA,KAAK,EACJ,MAAO,UAAUrG,IAClB,KAAK,EACJ,MAAO,mBAAmBA,EAAO,wBAAwBA,EAAO,KACjE,KAAK,EACJ,MAAO,cAAcA,EAAO,wBAAwBA,EAAO,qDACfA,EAAO,KACpD,KAAK,EACJ,MAAO,cAAcA,EAAO,mBAAmBA,EAAO,qDACVA,EAAO,kBAAkBA,EAAO,KAI/E,MAAO,UAAUA,GAClB,CA/CAhhD,EAAYE,YAAc,a,gsECrL1B,SAAgB,MAAQ,2BAA2B,OAAS,4BAA4B,WAAa,gCAAgC,qBAAqB,wCAAwC,KAAO,0BAA0B,OAAS,4BAA4B,MAAQ,2BAA2B,IAAM,yBAAyB,OAAS,4BAA4B,OAAS,4BAA4B,OAAS,4BAA4B,QAAU,6BAA6B,OAAS,4BAA4B,SAAW,8BAA8B,mBAAmB,sCAAsC,YAAY,+BAA+B,oBAAoB,uCAAuC,eAAe,kCAAkC,YAAY,+BAA+B,kBAAkB,qCAAqC,mBAAmB,sCAAsC,kBAAkB,qCAAqC,mBAAmB,sCAAsC,eAAe,kCAAkC,qBAAqB,wCAAwC,sBAAsB,yCAAyC,gBAAgB,mCAAmC,kBAAkB,qCAAqC,iBAAiB,oCAAoC,qBAAqB,wCAAwC,uBAAuB,0CAA0C,sBAAsB,yCAAyC,kBAAkB,qCAAqC,wBAAwB,2CAA2C,sBAAsB,0CCiBrpDyoD,EAAM,EAAGC,YAAAA,EAAa3pD,MAAAA,EAAO4pD,IAAAA,EAAKC,KAAAA,EAAMC,SAAAA,EAAUC,OAAAA,GAAS,EAAOxpD,UAAAA,KAAcC,MAC5F,MAAME,GAAaC,EAAAA,EAAAA,GAAK,CACvBC,EAAOopD,MACPL,GAAe/oD,EAAO,GAAG+oD,KACzBM,EAASjqD,EAAO2pD,GAChBC,GAAO,OAAOA,IACdC,GAAQjpD,EAAO,QAAQipD,KACvBC,GAAYlpD,EAAO,YAAYkpD,KAC/BC,GAAUnpD,EAAOmpD,OACjBvpD,EAAMM,SAAWF,EAAO,uBACxBL,IAGD,OACCd,EAAAA,cAACsB,EAAAA,GAAA,IAAgBP,EAAOD,UAAWG,GACjCF,EAAMQ,SACR,EAIF,SAASipD,EAASjqD,EAA+B2pD,GAChD,OAAKA,EAGDJ,MAAMC,QAAQxpD,GACVA,EAAMktC,KAAKgd,GAAOtpD,EAAOspD,KAAKhM,KAAK,KAGpCt9C,EAAOZ,GANN,EAOT,C,u3EC1CA,MAAMmqD,EAAgB,CACrBC,QAAU3O,GAAiB4O,EAAAA,EAAQhkB,IAAIoV,IAAS,KAChD6O,QAAS,CAAC7O,EAAc8O,IAAkBF,EAAAA,EAAQhO,IAAIZ,EAAM8O,EAAO,CAAEC,QAAS,IAC9EC,WAAahP,GAAiB4O,EAAAA,EAAQK,OAAOjP,IAmCxCkP,EAAe,oBASfC,EAAmBC,IACxB,GAAc,wCAAVA,EAAiD,CACpDrlB,QAAQG,MAAM,qCACd0kB,EAAAA,EAAQK,OAAO,YAAa,CAAEI,KAAM,MAGpC,MAAMC,EAZU,MACjB,MAAMC,EAAMC,aAAab,QAAQO,GAC3BO,EAAStN,SAASoN,GAAO,IAAK,IACpC,OAAOG,OAAOC,MAAMF,GAAU,EAAIA,GASnBG,GAAc,EAC5B,IACCJ,aAAaX,QAAQK,EAAc5M,OAAOgN,GAC3C,CAAC,MAEAvlB,QAAQyD,KAAK,oDACd,CAEA,OAAI8hB,GAtBiB,GAuBpBrlB,MACC,6JAGDulB,aAAaR,WAAWE,GACxB1kB,OAAOC,SAAS2d,QAAQ,kBAExB5d,OAAOC,SAAS2d,QAAQ,MAElB,CACR,CAGA,OAAAoH,aAAaR,WAAWE,IACjB,GAGKxiB,GAAcsF,EAAAA,EAAAA,IAAAA,EAC1B2O,EAAAA,EAAAA,KACC,CAACC,EAAKhW,KAAAA,CACLgC,cAAe,GACfijB,cAAc,EAEd/iB,iBAAkB,KAClB7oC,SAAS,EACTimC,MAAO,KAEP4lB,eAAe,EACfC,4BAA4B,EAC5BC,uBAAuB,EACvBC,sBAAsB,EACtBC,OAAO,EAEPC,kBAAmB,CAAChf,EAAIif,EAAe,OACtCtG,YAAW,KACVlJ,EAAI,CAAE9T,iBAAkB,KAAM7oC,SAAS,EAAO2oC,cAAeuE,GAAM,GAAI0e,cAAc,IACrFrlB,OAAOC,SAAS2d,QAAQgI,EAAY,GAClC,EAAC,EAGLC,iBAAmBC,GAAS1P,EAAI,CAAEkP,cAAeQ,IACjDC,8BAAgC9O,GAASb,EAAI,CAAEmP,2BAA4BtO,IAC3EiE,WAAa9W,IACZ,MAAMihB,EAAejlB,IAAMilB,aAC3B,GAAIV,EAAgBvgB,EAAQuC,IAC3B,OAGD,MAAMqf,EAAuBC,IAC5B,MAAMC,EAAe5C,MAAMC,QAAQ0C,GAASA,EAAQ,CAACA,GACrD,QAAK7hB,EAAQ+hB,WACND,EAAaE,MAAMC,GAASjiB,EAAQ+hB,UAAUG,SAASD,IAD/B,EAIhCjQ,EAAI,CACHhU,cAAegC,EAAQuC,GACvBrE,iBAAkB8B,EAClB3qC,SAAS,EACT4rD,cAAc,EACdG,sBAAuBQ,EAAoB,CAAC,UAAW,QAAS,YAChEP,qBAAsBO,EAAoB,CAAC,UAAW,OAAQ,QAAS,YACvEN,MAAwB,QAAjBthB,EAAQE,OAGZ+gB,GACH9lB,QAAQ2E,MAAM,4DAA2D,KAI5E,CACCsR,KAAM,YACN+Q,SAASC,EAAAA,EAAAA,KAAkB,IAAMtC,IACjCuC,WAAarF,IACZ,IAAIuD,EAAgBvD,GAAOhf,eAG3B,MAAO,CACNA,cAAegf,EAAMhf,cACrBkjB,cAAelE,EAAMkE,cACrBC,2BAA4BnE,EAAMmE,2BACnC,I,2uEClJJ,MCoBMmB,EAAc,CACnBC,MDrBmwB,oCCsBnwBC,QDtBuzB,sCCuBvzBC,IDvBy2B,mCC0Bp2BC,EAAS,EAAGxgB,KAAAA,KAEhB9sC,EAAAA,cAAC,OAAIc,WAAWI,EAAAA,EAAAA,GD5BqpB,+BC4BjoBgsD,EAAYpgB,KAC9C,IAAIgd,MAAM,IAAIyD,KAAK,MAAM9f,KAAI,CAAC+f,EAAGC,IACjCztD,EAAAA,cAAC,OAAI0tC,IAAK+f,EAAO3sD,UD9B8rB,wCCoC7sB4sD,EAAiB,CACtBC,QDrCiE,gCCsCjEC,UDtC6G,kCCuC7GC,SDvC0J,iCCwC1JC,SDxCsM,iCCyCtM5M,KDzC8O,6BC0C9Ohb,MD1CmR,8BC2CnR6nB,MD3CyT,+BC8CpTC,EAAc,CACnBC,KD/C8V,6BCgD9Vd,MDhD+a,8BCiD/aC,QDjDud,gCCkDvdC,IDlD6f,6BCqDxfa,EAAY,CACjBf,MAAO,KACPC,QAAS,KACTC,IAAK,MAGAc,EAAe,CACpBC,KD5D8kB,iCC6D9kBC,MD7D2nB,mCCgE/mB3hB,EAAS,EACrBnrC,SAAAA,EACAurC,KAAAA,EAAO,UACPtsC,QAAAA,EAAU,UACVP,QAAAA,GAAU,EACVa,UAAAA,EACA6rC,KAAAA,EACA2hB,cAAAA,EAAgB,OAChBC,WAAAA,EAAa,MACbC,SAAAA,EACAlM,OAAAA,EACAC,UAAAA,EACAC,aAAAA,EACAC,WAAAA,EACAC,YAAAA,EACAP,MAAAA,EACAsM,SAAAA,EACAC,SAAAA,KACG3tD,MAEH,MAAME,GAAaC,EAAAA,EAAAA,GAAK,CACvBohD,IAAUe,EAAAA,EAAAA,IAAUf,GACpBC,GAAa,cAAcA,IAC3BC,GAAgB,iBAAiBA,IACjCC,GAAc,eAAeA,IAC7BC,GAAe,gBAAgBA,IAC/BziD,GD1FkiB,gCAA3gB,+BC4FvBytD,EAAeltD,GACfwtD,EAAYlhB,IACXH,GAAQ1sC,KAAasB,GD9F+W,iCC+FrY4sD,EAAaG,GACbnM,GAAS,SAASA,IAClBrhD,IAGD,OACCd,EAAAA,cAAC,UAAO,YAAWyuD,EAAU3tD,UAAWG,EAAYytD,SAAUzuD,GAAWyuD,EAAU5jB,KAAK,YAAa/pC,GACnGd,GAAWD,EAAAA,cAACstD,EAAA,CAAOxgB,KAAMA,KACxB7sC,GAAW0sC,GACZ3sC,EAAAA,cAAC+hD,EAAAA,EAAA,CAAKC,OAAQrV,EAAM0V,OAAQkM,EAAYzhB,KAAM0hB,GAAaN,EAAUphB,KAErEvrC,EACF,E,eC3GF,SAAgB,KAAO,2BAA2B,yBAAyB,6CAA6C,uBAAuB,2CAA2C,qBAAqB,yCAAyC,uBAAuB,2CAA2C,sBAAsB,0CAA0C,kBAAkB,sCAAsC,wBAAwB,6CCS7botD,EAAO,EAAGzE,YAAAA,EAAappD,UAAAA,KAAcC,MACjD,MAAMsjD,GAAYnjD,EAAAA,EAAAA,GAAK,CAACC,EAAOytD,KAAM1E,GAAe/oD,EAAO,GAAG+oD,KAAgBppD,IAE9E,OAAOd,EAAAA,cAACsB,EAAAA,GAAA,IAAgBP,EAAOD,UAAWujD,GAAW,ECZtD,GAAgB,MAAQ,6BAA6B,eAAe,oCAAoC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,cAAc,mCAAmC,eAAe,oCAAoC,YAAY,iCAAiC,WAAW,gCAAgC,cAAc,mCAAmC,aAAa,kCAAkC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,aAAa,kCAAkC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,cAAc,mCAAmC,qBAAqB,0CAA0C,qBAAqB,0CAA0C,aAAa,kCAAkC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,YAAY,iCAAiC,aAAa,kCAAkC,UAAU,+BAA+B,SAAS,8BAA8B,YAAY,iCAAiC,WAAW,gCAAgC,UAAU,+BAA+B,UAAU,+BAA+B,UAAU,+BAA+B,UAAU,+BAA+B,UAAU,+BAA+B,UAAU,+BAA+B,UAAU,+BAA+B,UAAU,+BAA+B,UAAU,+BAA+B,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,YAAY,iCAAiC,mBAAmB,wCAAwC,mBAAmB,wCAAwC,cAAc,mCAAmC,cAAc,mCAAmC,YAAY,iCAAiC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,WAAW,gCAAgC,qBAAqB,0CAA0C,uBAAuB,4CAA4C,sBAAsB,2CAA2C,wBAAwB,6CAA6C,mBAAmB,yCC+B7snBwK,EAAQ,EAAG/jB,KAAAA,EAAM4e,WAAAA,EAAYvH,MAAAA,EAAOC,OAAAA,EAAQtV,KAAAA,EAAMhsC,UAAAA,KAAcC,MAC5E,MAAMsjD,GAAYnjD,EAAAA,EAAAA,GAAK,CACtBC,EAAO2tD,MACPhuD,EACAgqC,GAAQ3pC,EAAO,QAAQ2pC,KACvBqX,GAAShhD,EAAO,SAASghD,KACzBC,GAAUjhD,EAAO,UAAUihD,KAC3BtV,GAAQ3rC,EAAO,QAAQ2rC,KACvB4c,GAAcvoD,EAAO,cAAcuoD,OAGpC,OACC1pD,EAAAA,cAAC,WAASe,EAAOD,UAAWujD,GAC1BtjD,EAAMQ,SACR,E,+7EC7CF,SAAgB,KAAO,2BAA2B,WAAa,iCAAiC,UAAY,gCAAgC,kBAAkB,sCAAsC,kBAAkB,sCAAsC,oBAAoB,wCAAwC,mBAAmB,uCAAuC,eAAe,mCAAmC,kBAAkB,sCAAsC,kBAAkB,sCAAsC,gBAAgB,oCAAoC,eAAe,mCAAmC,kBAAkB,sCAAsC,aAAa,iCAAiC,eAAe,mCAAmC,cAAc,kCAAkC,sBAAsB,0CAA0C,2BAA2B,+CAA+C,uBAAuB,2CAA2C,qBAAqB,yCAAyC,oBAAoB,wCAAwC,0BAA0B,8CAA8C,qBAAqB,yCAAyC,uBAAuB,2CAA2C,+BAA+B,mDAAmD,yBAAyB,6CAA6C,iCAAiC,qDAAqD,kCAAkC,sDAAsD,wBAAwB,4CAA4C,oBAAoB,wCAAwC,wBAAwB,4CAA4C,oBAAoB,wCAAwC,sBAAsB,0CAA0C,qBAAqB,yCAAyC,qBAAqB,yCAAyC,qBAAqB,yCAAyC,sBAAsB,0CAA0C,+BAA+B,mDAAmD,2BAA2B,+CAA+C,yBAAyB,6CAA6C,yBAAyB,6CAA6C,wBAAwB,4CAA4C,yBAAyB,6CAA6C,2BAA2B,+CAA+C,mCAAmC,uDAAuD,6BAA6B,iDAAiD,qCAAqC,yDAAyD,sCAAsC,0DAA0D,4BAA4B,iDCoCxkGwtD,GAAOC,EAAAA,EAAAA,aACZ,EAAGzuD,MAAAA,EAAOC,QAAAA,EAAU,UAAWyuD,aAAAA,EAAcC,YAAAA,EAAaC,YAAAA,EAAaruD,UAAAA,KAAcC,GAASC,KAC7F,MAAMqjD,GAAYnjD,EAAAA,EAAAA,GAAK,CACtBC,EAAOiuD,KACPtuD,EACAN,GAAWW,EAAO,WAAWX,KAC7ByuD,GAAgB9tD,EAAO,iBAAiB8tD,KACxCC,GAAe/tD,EAAO,gBAAgB+tD,KACtCC,GAAehuD,EAAO,gBAAgBguD,KACtC5uD,GAASY,EAAO,SAASZ,KACzBQ,EAAMM,SAAWF,EAAO,yBAGzB,OACCnB,EAAAA,cAACsB,EAAAA,GAAA,IAAgBP,EAAOD,UAAWujD,EAAWrjD,IAAKA,GACjDD,EAAMQ,SACR,IAKHwtD,EAAKvtD,YAAc,M","sources":["webpack:///../src/base/components/common/primitives/Text.module.scss?d0b3","webpack:///../src/base/components/common/primitives/Text.tsx","webpack:///../src/base/core/graphql/index.ts","webpack:///../src/base/utils/analyticsHelperInternal.ts","webpack:///../src/founder/utils/translate.ts","webpack:///../src/base/components/common/Toast.tsx","webpack:///../src/base/components/common/Toast.module.scss?d2ec","webpack:///../src/base/utils/images.ts","webpack:///../src/base/core/CakeStore.ts","webpack:///../src/base/components/common/primitives/Icon.module.scss?8c95","webpack:///../src/base/components/common/primitives/Icon.tsx","webpack:///../src/base/core/ServerSentEvents.ts","webpack:///../src/base/hooks/useServerSentEvents.ts","webpack:///../src/base/components/common/primitives/BaseElement.tsx","webpack:///../src/base/components/common/primitives/Box.module.scss?4c86","webpack:///../src/base/components/common/primitives/Box.tsx","webpack:///../src/base/hooks/useOrgStore.ts","webpack:///../src/base/components/common/primitives/Button/Button.module.scss?8ff3","webpack:///../src/base/components/common/primitives/Button/Button.tsx","webpack:///../src/base/components/common/primitives/Line.module.scss?1476","webpack:///../src/base/components/common/primitives/Line.tsx","webpack:///../src/base/components/common/primitives/Shape.module.scss?7db3","webpack:///../src/base/components/common/primitives/Shape.tsx","webpack:///../src/base/components/common/primitives/Card.module.scss?88bd","webpack:///../src/base/components/common/primitives/Card.tsx"],"sourcesContent":["// extracted by mini-css-extract-plugin\nexport default {\"text\":\"text--Text-module--Pqwnr\",\"family-inter\":\"family-inter--Text-module--BCnAu\",\"family-caveat\":\"family-caveat--Text-module--Z0_HI\",\"family-signature\":\"family-signature--Text-module--koSG7\",\"text-display-inline\":\"text-display-inline--Text-module--alrtn\",\"text-variant-huge-title\":\"text-variant-huge-title--Text-module--C6MsZ\",\"text-variant-big-title\":\"text-variant-big-title--Text-module--j9Csl\",\"text-variant-comic-title\":\"text-variant-comic-title--Text-module--kdFic\",\"text-variant-title\":\"text-variant-title--Text-module--NAT_n\",\"text-variant-subtitle\":\"text-variant-subtitle--Text-module--qWS2e\",\"text-variant-regular\":\"text-variant-regular--Text-module--_2t5w\",\"text-variant-caption\":\"text-variant-caption--Text-module--EYSpv\",\"text-variant-helper\":\"text-variant-helper--Text-module--oy2it\",\"text-style-normal\":\"text-style-normal--Text-module--y10O0\",\"text-style-italic\":\"text-style-italic--Text-module--DH8Fe\",\"text-align-left\":\"text-align-left--Text-module--VpM7M\",\"text-align-center\":\"text-align-center--Text-module--OG6DP\",\"text-align-right\":\"text-align-right--Text-module--krVhz\",\"text-weight-light\":\"text-weight-light--Text-module--GOQqp\",\"text-weight-regular\":\"text-weight-regular--Text-module--mjuW0\",\"text-weight-medium\":\"text-weight-medium--Text-module--xCfuj\",\"text-weight-semi-bold\":\"text-weight-semi-bold--Text-module--Ey7x8\",\"text-weight-bold\":\"text-weight-bold--Text-module--WGLNp\",\"text-weight-extra-bold\":\"text-weight-extra-bold--Text-module--ywSIy\",\"text-color-black\":\"text-color-black--Text-module--uAopJ\",\"text-color-gray\":\"text-color-gray--Text-module--xEZDi\",\"text-color-white\":\"text-color-white--Text-module--RqEVr\",\"text-color-primary\":\"text-color-primary--Text-module--Tu86M\",\"text-color-secondary\":\"text-color-secondary--Text-module--JOYZX\",\"text-color-tertiary\":\"text-color-tertiary--Text-module--bP0n6\",\"text-color-tertiary-darker\":\"text-color-tertiary-darker--Text-module--AcLeE\",\"text-color-pink\":\"text-color-pink--Text-module--GYiNL\",\"text-color-error\":\"text-color-error--Text-module--_H0WX\",\"text-color-error-darker\":\"text-color-error-darker--Text-module--fIOXP\",\"text-color-success\":\"text-color-success--Text-module--RAqg6\",\"text-color-success-darker\":\"text-color-success-darker--Text-module--WWiZK\",\"text-color-inherit\":\"text-color-inherit--Text-module--Y0eSd\",\"text-transform-uppercase\":\"text-transform-uppercase--Text-module--WFPQm\",\"text-transform-lowercase\":\"text-transform-lowercase--Text-module--cGgWC\",\"text-transform-capitalize\":\"text-transform-capitalize--Text-module--GOPsr\",\"text-italic\":\"text-italic--Text-module--JLfgc\",\"text-underline\":\"text-underline--Text-module--MNODO\",\"size-full\":\"size-full--Text-module--KV7to\",\"size-full-width\":\"size-full-width--Text-module--e4eyY\",\"size-full-height\":\"size-full-height--Text-module--Rx7zD\",\"size-minimal\":\"size-minimal--Text-module--_aOhU\",\"size-minimal-width\":\"size-minimal-width--Text-module--dRd9J\",\"size-minimal-height\":\"size-minimal-height--Text-module--hQ5Q2\",\"one-line\":\"one-line--Text-module--eR5z9\",\"truncate\":\"truncate--Text-module--mCTgH\",\"show-pointer-cursor\":\"show-pointer-cursor--Text-module--U8Mo4\",\"loading\":\"loading--Text-module--EeR_A\",\"ellipsis\":\"ellipsis--Text-module--Uu5zI\"};","import clsx from \"clsx\";\nimport React from \"react\";\nimport { BaseElement, BaseElementProps } from \"./BaseElement\";\nimport styles from \"./Text.module.scss\";\n\nexport type textVariants =\n\t| \"huge-title\"\n\t| \"big-title\"\n\t| \"comic-title\"\n\t| \"title\"\n\t| \"subtitle\"\n\t| \"regular\"\n\t| \"caption\"\n\t| \"helper\";\n\nexport type textColors =\n\t| \"black\"\n\t| \"gray\"\n\t| \"white\"\n\t| \"primary\"\n\t| \"secondary\"\n\t| \"tertiary\"\n\t| \"tertiary-darker\"\n\t| \"error\"\n\t| \"error-darker\"\n\t| \"success\"\n\t| \"success-darker\"\n\t| \"pink\"\n\t| \"inherit\";\n\nexport type textWeights = \"extra-bold\" | \"bold\" | \"semi-bold\" | \"medium\" | \"regular\" | \"light\";\n\nexport interface TextProps extends BaseElementProps {\n\tclassName?: string;\n\tvariant?: textVariants;\n\tweight?: textWeights;\n\tcolor?: textColors;\n\talign?: \"left\" | \"right\" | \"center\";\n\tfontStyle?: \"normal\" | \"italic\";\n\tfamily?: \"inter\" | \"caveat\" | \"signature\";\n\ttransform?: \"lowercase\" | \"uppercase\" | \"capitalize\";\n\tloading?: boolean;\n\titalic?: boolean;\n\tisLiquid?: boolean;\n\tunderline?: boolean;\n\tmultiline?: boolean;\n\ttruncate?: boolean;\n\tchildren?: React.ReactNode;\n}\n\nexport const Text = React.forwardRef(\n\t(\n\t\t{\n\t\t\tloading,\n\t\t\tisLiquid,\n\t\t\tunderline,\n\t\t\titalic,\n\t\t\tmultiline,\n\t\t\ttruncate,\n\t\t\talign,\n\t\t\tvariant,\n\t\t\tfontStyle,\n\t\t\tweight,\n\t\t\tfamily,\n\t\t\tcolor,\n\t\t\ttransform,\n\t\t\tclassName,\n\t\t\t...props\n\t\t}: TextProps,\n\t\tref: React.Ref<HTMLDivElement>\n\t) => {\n\t\tconst cssClasses = clsx([\n\t\t\tstyles.text,\n\t\t\tclassName,\n\t\t\tloading && styles[`loading`],\n\t\t\titalic && styles[`text-italic`],\n\t\t\tisLiquid && styles[`text-display-inline`],\n\t\t\tunderline && styles[`text-underline`],\n\t\t\t!multiline && styles[`one-line`],\n\t\t\ttruncate && styles[`truncate`],\n\t\t\tvariant && styles[`text-variant-${variant}`],\n\t\t\tfontStyle && styles[`text-style-${fontStyle}`],\n\t\t\tcolor && styles[`text-color-${color}`],\n\t\t\ttransform && styles[`text-transform-${transform}`],\n\t\t\tweight && styles[`text-weight-${weight}`],\n\t\t\talign && styles[`text-align-${align}`],\n\t\t\tprops.onClick && styles[\"show-pointer-cursor\"],\n\t\t\tfamily && styles[`family-${family}`],\n\t\t]);\n\n\t\treturn (\n\t\t\t<BaseElement ref={ref} {...props} className={cssClasses}>\n\t\t\t\t{props.children}\n\t\t\t</BaseElement>\n\t\t);\n\t}\n);\nText.displayName = \"Text\";\n","/* eslint-disable max-len */\nimport { gql } from '@apollo/client';\nimport * as Apollo from '@apollo/client';\nimport { TypedDocumentNode } from '@graphql-typed-document-node/core';\nexport type Maybe<T> = T | null;\nexport type InputMaybe<T> = Maybe<T>;\nexport type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };\nexport type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };\nexport type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };\nexport type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };\nexport type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };\nconst defaultOptions = {} as const;\n/** All built-in and custom scalars, mapped to their actual values */\nexport type Scalars = {\n  ID: { input: string; output: string; }\n  String: { input: string; output: string; }\n  Boolean: { input: boolean; output: boolean; }\n  Int: { input: number; output: number; }\n  Float: { input: number; output: number; }\n  BigInt: { input: number; output: number; }\n  BoardApprovalCakeType: { input: string; output: string; }\n  CakeDecimal: { input: number; output: number; }\n  CakeGroupCakeType: { input: string; output: string; }\n  CakeMessageCakeType: { input: string; output: string; }\n  CakeReplyThreadCakeType: { input: string; output: string; }\n  CleanString: { input: string; output: string; }\n  Date: { input: string; output: string; }\n  DateTime: { input: string; output: string; }\n  Decimal: { input: number; output: number; }\n  DocumentCakeType: { input: string; output: string; }\n  EmailSenderCakeType: { input: string; output: string; }\n  EquityModelCakeType: { input: string; output: string; }\n  EsopCakeType: { input: string; output: string; }\n  EsopOfferCakeType: { input: string; output: string; }\n  EsopOfferGroupCakeType: { input: string; output: string; }\n  EsopOfferPauseEventCakeType: { input: string; output: string; }\n  EsopOfferQuerySetCakeType: { input: string; output: string; }\n  EssCakeType: { input: string; output: string; }\n  EssOfferCakeType: { input: string; output: string; }\n  EssOfferGroupCakeType: { input: string; output: string; }\n  EssOfferPauseEventCakeType: { input: string; output: string; }\n  EssOfferQuerySetCakeType: { input: string; output: string; }\n  FounderVestingCakeType: { input: string; output: string; }\n  FounderVestingOfferCakeType: { input: string; output: string; }\n  FounderVestingOfferGroupCakeType: { input: string; output: string; }\n  FounderVestingOfferPauseEventCakeType: { input: string; output: string; }\n  FounderVestingOfferQuerySetCakeType: { input: string; output: string; }\n  GenericScalar: { input: JSON; output: JSON; }\n  Historical409ACakeType: { input: string; output: string; }\n  JSONString: { input: string; output: string; }\n  NoteCakeType: { input: string; output: string; }\n  NotesRoundCakeType: { input: string; output: string; }\n  NotesRoundOfferCakeType: { input: string; output: string; }\n  OffboardingCakeType: { input: string; output: string; }\n  OfferGroupCakeType: { input: string; output: string; }\n  OfficeholderCakeType: { input: string; output: string; }\n  OptionExerciseRequestCakeType: { input: string; output: string; }\n  OptionExerciseRequestSettingsCakeType: { input: string; output: string; }\n  OrganisationCakeType: { input: string; output: string; }\n  OrganisationRaiseCakeType: { input: string; output: string; }\n  OrganisationRaiseOfferCakeType: { input: string; output: string; }\n  PositiveInteger: { input: number; output: number; }\n  PositiveIntegerOrZero: { input: number; output: number; }\n  RsuCakeType: { input: string; output: string; }\n  RsuConversionLockEventQuerySetCakeType: { input: string; output: string; }\n  RsuOfferCakeType: { input: string; output: string; }\n  RsuOfferGroupCakeType: { input: string; output: string; }\n  RsuOfferPauseEventCakeType: { input: string; output: string; }\n  RsuOfferQuerySetCakeType: { input: string; output: string; }\n  ScanbotDocumentCakeType: { input: string; output: string; }\n  ShareCertificateDisclaimerCakeType: { input: string; output: string; }\n  ShareTransferOfferCakeType: { input: string; output: string; }\n  ShareTransferRoundCakeType: { input: string; output: string; }\n  ShareholderCakeType: { input: string; output: string; }\n  ShareholdingTransactionCakeType: { input: string; output: string; }\n  SharetypeCakeType: { input: string; output: string; }\n  UUID: { input: string; output: string; }\n  UserCakeType: { input: string; output: string; }\n  ValuationCakeType: { input: string; output: string; }\n  VestingScheduleTemplateCakeType: { input: string; output: string; }\n  WarrantCakeType: { input: string; output: string; }\n  WarrantOfferCakeType: { input: string; output: string; }\n  WarrantOfferGroupCakeType: { input: string; output: string; }\n  WarrantOfferPauseEventCakeType: { input: string; output: string; }\n  WarrantOfferQuerySetCakeType: { input: string; output: string; }\n};\n\n/**\n * mutation {\n *     acceptEquityOffer(\n *         offer: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type AcceptEquityOffer = {\n  __typename?: 'AcceptEquityOffer';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     acceptNotesOffer (\n *         offer: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type AcceptNotesOffer = {\n  __typename?: 'AcceptNotesOffer';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type ActionItemOutputType = {\n  __typename?: 'ActionItemOutputType';\n  actionType?: Maybe<Scalars['CleanString']['output']>;\n  actionableId?: Maybe<Scalars['UUID']['output']>;\n  description?: Maybe<Scalars['CleanString']['output']>;\n  itemDate?: Maybe<Scalars['Date']['output']>;\n  link?: Maybe<Scalars['CleanString']['output']>;\n  recent?: Maybe<Scalars['Boolean']['output']>;\n  shDisplayName?: Maybe<Scalars['CleanString']['output']>;\n  snooze?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type ActivityLogEntryType = {\n  __typename?: 'ActivityLogEntryType';\n  created: Scalars['DateTime']['output'];\n  duration: Scalars['BigInt']['output'];\n  id: Scalars['UUID']['output'];\n  name?: Maybe<Scalars['CleanString']['output']>;\n  operationKey: Scalars['String']['output'];\n  operationName: Scalars['String']['output'];\n  organisation?: Maybe<Organisation>;\n  payload: Scalars['JSONString']['output'];\n  supportAdminOnly?: Maybe<Scalars['Boolean']['output']>;\n  timestamp: Scalars['DateTime']['output'];\n  user?: Maybe<UserType>;\n};\n\n/**\n *\n *     # This mutation adds a buy back to a Sharetype.\n *\n *         mutation Example {\n *         addBuyBack(\n *             addBuyBackData:\n *             {\n *                 amount: 1000.50,\n *                 shares: 300,\n *                 shareholder: \"9280926e-8bae-4481-9d2c-d6a2d9694055\",\n *                 shareType: \"beb6dd77-53b1-4f5a-9e43-da52c1eb8973\",\n *                 buyBackDate: \"2010-10-24\"\n *             })\n *         {\n *         shareholdingTransaction\n *         {\n *             id\n *         }\n *         }\n *         }\n *\n */\nexport type AddBuyBack = {\n  __typename?: 'AddBuyBack';\n  shareholdingTransaction?: Maybe<ShareholdingTransaction>;\n};\n\nexport type AddBuyBackInput = {\n  amount: Scalars['CakeDecimal']['input'];\n  beneficiary?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  buyBackDate: Scalars['Date']['input'];\n  shareType: Scalars['SharetypeCakeType']['input'];\n  shareholder: Scalars['ShareholderCakeType']['input'];\n  shares: Scalars['PositiveInteger']['input'];\n};\n\n/**\n * mutation {\n *     addEquityRoundOffer(\n *         round: \"00000000-0000-0000-0000-000000000000\",\n *         shareholder: \"00000000-0000-0000-0000-000000000000\",\n *         amount: 10,\n *         reminderSentDate: \"2010-10-24\"\n *     )\n *     { organisationRaiseOffer { id } }\n * }\n */\nexport type AddEquityRoundOffer = {\n  __typename?: 'AddEquityRoundOffer';\n  organisationRaiseOffer?: Maybe<OrganisationRaiseOffer>;\n};\n\n/**\n *\n *     # This mutation Adds a new officeholder. Ensure organisationId\n *     # provided exists and user running the query is an Officeholder.\n *\n *     mutation Example {\n *             addOfficeholder (addOfficeholderData:\n *             {\n *             organisationId: \"b280926e-8bae-4481-9d2c-d6a2d969400b\",\n *             officeholder :\n *             {\n *             name: \"John Doe\",\n *             roles: [{\n *                 role: \"DIR\",\n *             }]\n *             email: \"john.doe@example.com\",\n *             }\n *             })\n *             {\n *             officeholder\n *                 {\n *                 id\n *                 name\n *                 roles { role, name}\n *                 email\n *                 signer\n *                 signature\n *             }\n *             }\n *             }\n *\n *\n */\nexport type AddOfficeholder = {\n  __typename?: 'AddOfficeholder';\n  officeholder?: Maybe<Officeholder>;\n};\n\nexport type AddOfficeholderData = {\n  officeholder?: InputMaybe<OfficeholderInput>;\n  organisationId: Scalars['UUID']['input'];\n};\n\nexport type AddOrUpdateCompanySignersInput = {\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  id?: InputMaybe<Scalars['UUID']['input']>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  roles?: InputMaybe<Array<InputMaybe<OfficeholderRoleInputType>>>;\n  signer: Scalars['String']['input'];\n};\n\n/** An enumeration. */\nexport enum AddonType {\n  GlobalTeams = 'GLOBAL_TEAMS',\n  Qsbs = 'QSBS',\n  Valuation_409A = 'VALUATION_409A'\n}\n\nexport type AddressInput = {\n  administrativeArea1?: InputMaybe<Scalars['String']['input']>;\n  administrativeArea2?: InputMaybe<Scalars['String']['input']>;\n  country?: InputMaybe<Scalars['String']['input']>;\n  line1?: InputMaybe<Scalars['String']['input']>;\n  line2?: InputMaybe<Scalars['String']['input']>;\n  line3?: InputMaybe<Scalars['String']['input']>;\n  locality?: InputMaybe<Scalars['String']['input']>;\n  postcode?: InputMaybe<Scalars['String']['input']>;\n};\n\nexport type AnyOffer = EsopOffer | EssOffer | NotesRoundOfferType | OrganisationRaiseOffer | RsuOfferOutputType | ShareTransferOfferType;\n\nexport type AnyVestableOffer = EsopOffer | EssOffer | RsuOfferOutputType;\n\nexport type AnyVestingOffer = EsopOffer | EssOffer | RsuOfferOutputType | WarrantOfferOutputType;\n\nexport type AuCompanyDetailsField = {\n  __typename?: 'AuCompanyDetailsField';\n  abn?: Maybe<Scalars['String']['output']>;\n  acn?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  registeredAddress?: Maybe<InternationalAddressField>;\n  registeredAgentEmail?: Maybe<Scalars['String']['output']>;\n  registeredAgentName?: Maybe<Scalars['String']['output']>;\n  registrationLocation?: Maybe<Scalars['String']['output']>;\n};\n\nexport type AuCompanyDetailsInput = {\n  acn: Scalars['CleanString']['input'];\n  registeredAddress?: InputMaybe<AddressInput>;\n  registeredAgentEmail?: InputMaybe<Scalars['String']['input']>;\n  registeredAgentName?: InputMaybe<Scalars['String']['input']>;\n  registrationLocation: Scalars['CleanString']['input'];\n};\n\nexport type AuPaymentDetailsType = {\n  __typename?: 'AuPaymentDetailsType';\n  accountName?: Maybe<Scalars['String']['output']>;\n  accountNumber?: Maybe<Scalars['String']['output']>;\n  bsb?: Maybe<Scalars['String']['output']>;\n  isTrustAccount?: Maybe<Scalars['Boolean']['output']>;\n  reference?: Maybe<Scalars['String']['output']>;\n};\n\nexport type AvailableOrganisationPositions = {\n  __typename?: 'AvailableOrganisationPositions';\n  positions?: Maybe<Array<Maybe<PositionWithDescription>>>;\n};\n\nexport type AvailableOrganisationRoles = {\n  __typename?: 'AvailableOrganisationRoles';\n  roles?: Maybe<Array<Maybe<RoleWithDescription>>>;\n};\n\nexport type BareTrustInput = {\n  name: Scalars['CleanString']['input'];\n};\n\nexport type BillingAvatar = {\n  __typename?: 'BillingAvatar';\n  name?: Maybe<Scalars['String']['output']>;\n  picture?: Maybe<Scalars['String']['output']>;\n};\n\nexport type BillingDetails = {\n  __typename?: 'BillingDetails';\n  ccLast4?: Maybe<Scalars['String']['output']>;\n};\n\nexport type BillingStakeholder = {\n  __typename?: 'BillingStakeholder';\n  displayName?: Maybe<Scalars['String']['output']>;\n  hasActiveEquityRaiseOffer?: Maybe<Scalars['Boolean']['output']>;\n  hasActiveEsopOffer?: Maybe<Scalars['Boolean']['output']>;\n  hasActiveEssOffer?: Maybe<Scalars['Boolean']['output']>;\n  hasActiveNotesRaiseOffer?: Maybe<Scalars['Boolean']['output']>;\n  hasActiveRsuOffer?: Maybe<Scalars['Boolean']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  isBeneficiary?: Maybe<Scalars['Boolean']['output']>;\n  isNoteholder?: Maybe<Scalars['Boolean']['output']>;\n  isShareholder?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type BoardApprovalType = {\n  __typename?: 'BoardApprovalType';\n  autoGrant: Scalars['Boolean']['output'];\n  contract?: Maybe<Document>;\n  created: Scalars['DateTime']['output'];\n  createdBy?: Maybe<UserType>;\n  esopOffers?: Maybe<Array<Maybe<EsopOfferApprovalItem>>>;\n  esopofferSet: Array<EsopOffer>;\n  essofferSet: Array<EssOffer>;\n  foundervestingofferSet: Array<FounderVestingOfferOutputType>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  planName?: Maybe<Scalars['String']['output']>;\n  rsuofferSet: Array<RsuOfferOutputType>;\n  signatureId?: Maybe<Scalars['String']['output']>;\n  signerEmail?: Maybe<Scalars['String']['output']>;\n  signerName?: Maybe<Scalars['String']['output']>;\n  signingLink?: Maybe<Scalars['String']['output']>;\n  status: BoardapprovalsBoardApprovalStatusChoices;\n  warrantofferSet: Array<WarrantOfferOutputType>;\n};\n\n/** An enumeration. */\nexport enum BoardapprovalsBoardApprovalStatusChoices {\n  /** Done */\n  Done = 'DONE',\n  /** Waiting */\n  Waiting = 'WAITING'\n}\n\nexport type CaCompanyDetailsField = {\n  __typename?: 'CaCompanyDetailsField';\n  bn?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  registeredAddress?: Maybe<InternationalAddressField>;\n};\n\nexport type CaCompanyDetailsInput = {\n  bn: Scalars['CleanString']['input'];\n  registeredAddress?: InputMaybe<AddressInput>;\n};\n\nexport type CakeAddonType = {\n  __typename?: 'CakeAddonType';\n  canBePurchased?: Maybe<Scalars['Boolean']['output']>;\n  internalId?: Maybe<Scalars['String']['output']>;\n  price?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type CakeGroupType = {\n  __typename?: 'CakeGroupType';\n  count?: Maybe<Scalars['Int']['output']>;\n  created: Scalars['DateTime']['output'];\n  createdBy?: Maybe<UserType>;\n  esop?: Maybe<Esop>;\n  ess?: Maybe<Ess>;\n  groupType: SeCakeGroupGroupTypeChoices;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  name?: Maybe<Scalars['String']['output']>;\n  notesround?: Maybe<NotesRoundType>;\n  officeholders: Array<Officeholder>;\n  organisationRaise?: Maybe<OrganisationRaise>;\n  rsu?: Maybe<RsuOutputType>;\n  shareholders: Array<Shareholder>;\n  sharetransferround?: Maybe<ShareTransferRoundType>;\n  sharetype?: Maybe<Sharetype>;\n  users?: Maybe<Array<Maybe<GroupUser>>>;\n  warrant?: Maybe<WarrantOutputType>;\n};\n\nexport type CakeMessageReactionCountType = {\n  __typename?: 'CakeMessageReactionCountType';\n  count?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  reaction?: Maybe<Scalars['CleanString']['output']>;\n  stakeholders?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\nexport type CakeMessageType = {\n  __typename?: 'CakeMessageType';\n  allowReactions: Scalars['Boolean']['output'];\n  allowReplies?: Maybe<Scalars['Boolean']['output']>;\n  attachments: Array<Document>;\n  body: Scalars['String']['output'];\n  bodyParsed?: Maybe<Scalars['String']['output']>;\n  cakereplythreadSet: Array<CakeReplyThreadType>;\n  created: Scalars['DateTime']['output'];\n  draft?: Maybe<DraftMessagePayloadType>;\n  draftPayload?: Maybe<Scalars['JSONString']['output']>;\n  id: Scalars['UUID']['output'];\n  isCompanyMessage?: Maybe<Scalars['Boolean']['output']>;\n  isDraft?: Maybe<Scalars['Boolean']['output']>;\n  isSeen?: Maybe<Scalars['Boolean']['output']>;\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  ownReaction?: Maybe<Scalars['String']['output']>;\n  reactionAggregates?: Maybe<Array<Maybe<CakeMessageReactionCountType>>>;\n  replyThread?: Maybe<CakeReplyThreadType>;\n  shareholders?: Maybe<Array<Maybe<Shareholder>>>;\n  subject: Scalars['String']['output'];\n  user?: Maybe<UserType>;\n};\n\n\nexport type CakeMessageTypeIsSeenArgs = {\n  isCompany?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\nexport type CakeMessageTypeShareholdersArgs = {\n  limit?: InputMaybe<Scalars['PositiveInteger']['input']>;\n};\n\nexport type CakePartner = {\n  __typename?: 'CakePartner';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  /** URL to Partner logo */\n  logo: Scalars['String']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** Partner Name */\n  name: Scalars['String']['output'];\n  organisationSet: Array<Organisation>;\n};\n\nexport type CakePlanType = {\n  __typename?: 'CakePlanType';\n  availableAddons?: Maybe<Array<Maybe<CakeAddonType>>>;\n  currency?: Maybe<Scalars['String']['output']>;\n  description?: Maybe<Scalars['String']['output']>;\n  image?: Maybe<Scalars['String']['output']>;\n  internalId?: Maybe<Scalars['String']['output']>;\n  isAvailable?: Maybe<Scalars['Boolean']['output']>;\n  link?: Maybe<Scalars['String']['output']>;\n  maxInvestors?: Maybe<Scalars['Int']['output']>;\n  name?: Maybe<Scalars['String']['output']>;\n  order?: Maybe<Scalars['String']['output']>;\n  perheadIncluded?: Maybe<Scalars['CakeDecimal']['output']>;\n  perheadPrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  perheadPriceId?: Maybe<Scalars['String']['output']>;\n  price?: Maybe<Scalars['CakeDecimal']['output']>;\n  priceId?: Maybe<Scalars['String']['output']>;\n  version?: Maybe<Scalars['Int']['output']>;\n};\n\nexport type CakeReplyThreadType = {\n  __typename?: 'CakeReplyThreadType';\n  created: Scalars['DateTime']['output'];\n  createdBy?: Maybe<UserType>;\n  id: Scalars['UUID']['output'];\n  investorMessages?: Maybe<PaginatedMessageType>;\n  lastMessageAt?: Maybe<Scalars['DateTime']['output']>;\n  messages: Array<CakeMessageType>;\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  organisationMessages?: Maybe<PaginatedMessageType>;\n  participants: Array<Shareholder>;\n  replyingShareholders?: Maybe<Array<Maybe<Shareholder>>>;\n  rootMessage: CakeMessageType;\n};\n\n\nexport type CakeReplyThreadTypeInvestorMessagesArgs = {\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  page?: InputMaybe<Scalars['PositiveInteger']['input']>;\n};\n\n\nexport type CakeReplyThreadTypeOrganisationMessagesArgs = {\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  page?: InputMaybe<Scalars['PositiveInteger']['input']>;\n};\n\n\nexport type CakeReplyThreadTypeReplyingShareholdersArgs = {\n  isCompany?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\nexport type CancelNote = {\n  __typename?: 'CancelNote';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type ChecklistItem = {\n  __typename?: 'ChecklistItem';\n  completed?: Maybe<Scalars['Boolean']['output']>;\n  description?: Maybe<Scalars['CleanString']['output']>;\n  key?: Maybe<Scalars['CleanString']['output']>;\n  recommended?: Maybe<Scalars['Boolean']['output']>;\n  title?: Maybe<Scalars['CleanString']['output']>;\n  userPreference?: Maybe<Scalars['CleanString']['output']>;\n};\n\nexport enum CommentModelTypeEnum {\n  Esop = 'ESOP',\n  EsopTransaction = 'ESOP_TRANSACTION',\n  Ess = 'ESS',\n  EssTransaction = 'ESS_TRANSACTION',\n  Rsu = 'RSU',\n  RsuTransaction = 'RSU_TRANSACTION',\n  SharesTransaction = 'SHARES_TRANSACTION'\n}\n\nexport type CommentType = {\n  __typename?: 'CommentType';\n  content: Scalars['String']['output'];\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  user?: Maybe<UserType>;\n};\n\nexport type CompanyDataType = {\n  __typename?: 'CompanyDataType';\n  contactPerson?: Maybe<Scalars['String']['output']>;\n  identifierNumber?: Maybe<Scalars['String']['output']>;\n  identifierType?: Maybe<IdentifierTypeOutputField>;\n  signers?: Maybe<Array<Maybe<CompanySignerInfoType>>>;\n};\n\nexport type CompanyDetailsField = AuCompanyDetailsField | CaCompanyDetailsField | EeCompanyDetailsField | GbCompanyDetailsField | InCompanyDetailsField | NzCompanyDetailsField | SgCompanyDetailsField | UsCompanyDetailsField;\n\nexport type CompanyInvestorDataInput = {\n  contactPerson?: InputMaybe<Scalars['CleanString']['input']>;\n  identifierNumber?: InputMaybe<Scalars['CleanString']['input']>;\n  identifierType?: InputMaybe<IdentifierType>;\n  signers: Array<InputMaybe<CompanySignerInfoInput>>;\n};\n\n/** An enumeration. */\nexport enum CompanyRole {\n  AuthorisedSigner = 'AUTHORISED_SIGNER',\n  Both = 'BOTH',\n  Director = 'DIRECTOR',\n  Officer = 'OFFICER',\n  President = 'PRESIDENT',\n  Secretary = 'SECRETARY'\n}\n\nexport enum CompanyRoleOutputField {\n  AuthorisedSigner = 'AUTHORISED_SIGNER',\n  Both = 'BOTH',\n  Director = 'DIRECTOR',\n  Officer = 'OFFICER',\n  President = 'PRESIDENT',\n  Secretary = 'SECRETARY'\n}\n\nexport type CompanySignerInfoInput = {\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  role: CompanyRole;\n};\n\nexport type CompanySignerInfoType = {\n  __typename?: 'CompanySignerInfoType';\n  email?: Maybe<Scalars['CleanString']['output']>;\n  name?: Maybe<Scalars['CleanString']['output']>;\n  role?: Maybe<CompanyRoleOutputField>;\n};\n\nexport type CompleteShareTransferOffer = {\n  __typename?: 'CompleteShareTransferOffer';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     confirmEquityOfferInvestorDetails (\n *         offer: \"00000000-0000-0000-0000-000000000000\",\n *         investorData: {}\n *     ) { ok }\n * }\n */\nexport type ConfirmEquityOfferInvestorDetails = {\n  __typename?: 'ConfirmEquityOfferInvestorDetails';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type ConfirmExercisePaymentAndIssueShares = {\n  __typename?: 'ConfirmExercisePaymentAndIssueShares';\n  exerciseTransaction?: Maybe<ExerciseTransactionDataType>;\n};\n\n/**\n * mutation {\n *     confirmNotesOfferInvestorDetails (\n *         offer: \"00000000-0000-0000-0000-000000000000\",\n *         investorData: { investors: [] }\n *     ) { ok }\n * }\n */\nexport type ConfirmNotesOfferInvestorDetails = {\n  __typename?: 'ConfirmNotesOfferInvestorDetails';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type ConfirmShareTransferOfferInvestorDetails = {\n  __typename?: 'ConfirmShareTransferOfferInvestorDetails';\n  transferOffer?: Maybe<ShareTransferOfferType>;\n};\n\nexport type ConfirmUserInvite = {\n  __typename?: 'ConfirmUserInvite';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/** An enumeration. */\nexport enum ContractType {\n  BareTrustDeed = 'BARE_TRUST_DEED',\n  BeneficialHoldings = 'BENEFICIAL_HOLDINGS',\n  BlankContract = 'BLANK_CONTRACT',\n  BoardApproval = 'BOARD_APPROVAL',\n  ConvertibleNote = 'CONVERTIBLE_NOTE',\n  ConvertibleNoteLlc = 'CONVERTIBLE_NOTE_LLC',\n  DirectorsResolution = 'DIRECTORS_RESOLUTION',\n  ExerciseNotice = 'EXERCISE_NOTICE',\n  GlobalOfferLetter = 'GLOBAL_OFFER_LETTER',\n  GlobalOfferLetterEss = 'GLOBAL_OFFER_LETTER_ESS',\n  GlobalOfferLetterRsu = 'GLOBAL_OFFER_LETTER_RSU',\n  NoteDeedOfAccession = 'NOTE_DEED_OF_ACCESSION',\n  NoteNoticeOfConversion = 'NOTE_NOTICE_OF_CONVERSION',\n  OfferLetter = 'OFFER_LETTER',\n  OfferLetterEss = 'OFFER_LETTER_ESS',\n  OfferLetterFoundervesting = 'OFFER_LETTER_FOUNDERVESTING',\n  OfferLetterPhantom = 'OFFER_LETTER_PHANTOM',\n  OfferLetterRsu = 'OFFER_LETTER_RSU',\n  OfferLetterWarrant = 'OFFER_LETTER_WARRANT',\n  PlanRules = 'PLAN_RULES',\n  PlanRulesEss = 'PLAN_RULES_ESS',\n  PlanRulesFoundervesting = 'PLAN_RULES_FOUNDERVESTING',\n  PlanRulesPhantom = 'PLAN_RULES_PHANTOM',\n  PlanRulesRsu = 'PLAN_RULES_RSU',\n  PlanRulesWarrant = 'PLAN_RULES_WARRANT',\n  SafeNote = 'SAFE_NOTE',\n  SafeNoteLlc = 'SAFE_NOTE_LLC',\n  ShareholdersResolution = 'SHAREHOLDERS_RESOLUTION',\n  ShareCertificate = 'SHARE_CERTIFICATE',\n  ShareCertificateTransactional = 'SHARE_CERTIFICATE_TRANSACTIONAL',\n  ShareTransferAgreement = 'SHARE_TRANSFER_AGREEMENT',\n  SubscriptionAgreement = 'SUBSCRIPTION_AGREEMENT'\n}\n\n/**\n * mutation {\n *     convertNote (\n *         noteId: \"00000000-0000-0000-0000-000000000000\",\n *         sharetypeId: \"00000000-0000-0000-0000-000000000000\",\n *         valuation: 4000,\n *         pricePerShare: 12.10\n *     ) {\n *         sharesIssued\n *     }\n * }\n */\nexport type ConvertNote = {\n  __typename?: 'ConvertNote';\n  investmentAmount?: Maybe<Scalars['CakeDecimal']['output']>;\n  sharesIssued?: Maybe<Scalars['BigInt']['output']>;\n};\n\n/**\n * mutation {\n *     convertNoteManual (\n *         noteId: \"00000000-0000-0000-0000-000000000000\",\n *         sharetypeId: \"00000000-0000-0000-0000-000000000000\",\n *         conversionShares: 4\n *     ) {\n *         sharesIssued\n *     }\n * }\n */\nexport type ConvertNoteManual = {\n  __typename?: 'ConvertNoteManual';\n  investmentAmount?: Maybe<Scalars['CakeDecimal']['output']>;\n  sharesIssued?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type ConvertShares = {\n  __typename?: 'ConvertShares';\n  transactionFrom?: Maybe<ShareholdingTransaction>;\n  transactionTo?: Maybe<ShareholdingTransaction>;\n};\n\nexport type CopyMoveFileOrFolder = {\n  __typename?: 'CopyMoveFileOrFolder';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type CountriesAndStatesType = {\n  __typename?: 'CountriesAndStatesType';\n  countries?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n  states?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\nexport type CouponType = {\n  __typename?: 'CouponType';\n  duration?: Maybe<Scalars['String']['output']>;\n  durationInMonths?: Maybe<Scalars['Int']['output']>;\n  isPercentage?: Maybe<Scalars['Boolean']['output']>;\n  value?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type CreateCakeGroup = {\n  __typename?: 'CreateCakeGroup';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type CreateDemoOrg = {\n  __typename?: 'CreateDemoOrg';\n  organisation?: Maybe<Organisation>;\n};\n\n/**\n *\n *     # This mutation creates a draft contract, eg. from a Directors Resolution\n *     # contract, Shareholders Resolution contract, etc.\n *\n *         mutation Example {\n *             createDraftContract(\n *                 organisation: \"d280926e-8bae-4481-9d2c-d6a2d9694999\",\n *                 contractType: \"SHARE_CERTIFICATE\"\n *             ) {\n *               ok\n *             }\n *         }\n *\n */\nexport type CreateDraftContract = {\n  __typename?: 'CreateDraftContract';\n  doc?: Maybe<Document>;\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     createEquityRound(\n *         organisation: \"00000000-0000-0000-0000-000000000000\",\n *         name: \"Seed Round\",\n *         raiseGoalAmount: 1000000,\n *         valuation: \"00000000-0000-0000-0000-000000000000\",\n *         existingShares: 300000,\n *         shareType: \"00000000-0000-0000-0000-000000000000\"\n *     )\n *     { organisationRaise { id } }\n * }\n */\nexport type CreateEquityRound = {\n  __typename?: 'CreateEquityRound';\n  organisationRaise?: Maybe<OrganisationRaise>;\n};\n\nexport type CreateFolder = {\n  __typename?: 'CreateFolder';\n  folders?: Maybe<Array<Maybe<Document>>>;\n};\n\n/**\n * mutation {\n *     createNote (\n *         shareholderId: \"00000000-0000-0000-0000-000000000000\",\n *         noteType: \"SAFE\",\n *         principal: 1000000\n *     ) { id type principal }\n * }\n */\nexport type CreateNote = {\n  __typename?: 'CreateNote';\n  note?: Maybe<Note>;\n};\n\nexport type CreateNotesRaiseAndOfficeholders = {\n  __typename?: 'CreateNotesRaiseAndOfficeholders';\n  notesRound?: Maybe<NotesRoundType>;\n};\n\n/**\n * mutation {\n *     createNotesRound (\n *         organisationId: \"00000000-0000-0000-0000-000000000000\",\n *         name: \"Name\",\n *         noteType: \"SAFE\",\n *         roundInvestmentGoal: 1000,\n *         capitalRaisingEventAmount: 1000,\n *         endDate: \"2020-05-03\",\n *         discountRate: 30,\n *         valuationCap: 1000000,\n *         interest: 8,\n *         maturityDate: \"2020-05-03\"\n *     ) {\n *         notesRound { id name }\n *     }\n * }\n */\nexport type CreateNotesRound = {\n  __typename?: 'CreateNotesRound';\n  notesRound?: Maybe<NotesRoundType>;\n};\n\n/**\n * mutation {\n *     createNotesRoundOffer (\n *         round: \"00000000-0000-0000-0000-000000000000\",\n *         shareholder: \"00000000-0000-0000-0000-000000000000\",\n *         principal: 10,\n *     ) { id type principal }\n * }\n */\nexport type CreateNotesRoundOffer = {\n  __typename?: 'CreateNotesRoundOffer';\n  notesRoundOffer?: Maybe<NotesRoundOfferType>;\n};\n\n/**\n * mutation {\n *     createNotesRoundTemplate (\n *         round: \"00000000-0000-0000-0000-000000000000\",\n *         name: \"Cool Convert\"\n *     ) { ok }\n * }\n */\nexport type CreateNotesRoundTemplate = {\n  __typename?: 'CreateNotesRoundTemplate';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type CreateOrUpdateSharetypeInput = {\n  authorisedShares?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  dividend?: InputMaybe<Scalars['Boolean']['input']>;\n  id?: InputMaybe<Scalars['UUID']['input']>;\n  name: Scalars['CleanString']['input'];\n  symbol: Scalars['CleanString']['input'];\n  voting?: InputMaybe<Scalars['Boolean']['input']>;\n  weight?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n/**\n * mutation createOrganisationSignup {\n *     createOrganisationSignup(\n *         name: \"Company Name\",\n *         country: \"AU\"\n *     ) { organisation { id } }\n * }\n */\nexport type CreateOrganisationSignup = {\n  __typename?: 'CreateOrganisationSignup';\n  organisation?: Maybe<Organisation>;\n};\n\nexport type CreateShareTransferOffer = {\n  __typename?: 'CreateShareTransferOffer';\n  transferOffer?: Maybe<ShareTransferOfferType>;\n};\n\nexport type CreateShareTransferRound = {\n  __typename?: 'CreateShareTransferRound';\n  transferRound?: Maybe<ShareTransferRoundType>;\n};\n\nexport type CreateShareTransferRoundTemplate = {\n  __typename?: 'CreateShareTransferRoundTemplate';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n *\n *     # This mutation Creates a new Sharetype under an Organisation.\n *     # Ensure organisationId provided exists.\n *\n *     mutation Example {\n *\n *      createShareType(createSharetypeData:\n *      {organisationId: \"bdd66da8-22ce-40e7-8ec1-5d880c25929a\",\n *      sharetype: {name:\"ORDINARY\", symbol: \"ORD\",\n *                 voting: false, dividend: false,\n *                 }})\n *        {\n *          sharetype {\n *            id\n *            name\n *            voting\n *            dividend\n *            symbol\n *            totals {\n *             amountRaised\n *             totalShares\n *             totalDue\n *            }\n *          }\n *        }\n *        }\n *\n */\nexport type CreateShareType = {\n  __typename?: 'CreateShareType';\n  sharetype?: Maybe<Sharetype>;\n};\n\nexport type CreateShareTypeInput = {\n  organisationId: Scalars['UUID']['input'];\n  sharetype?: InputMaybe<ShareTypeInput>;\n};\n\n/** An enumeration. */\nexport enum CustomerIoMailTemplates {\n  AnnualRenewalReminder = 'ANNUAL_RENEWAL_REMINDER',\n  AutoVestingEmail = 'AUTO_VESTING_EMAIL',\n  EarlyExerciseEmail = 'EARLY_EXERCISE_EMAIL',\n  EarlyExerciseReminderWithoutForm = 'EARLY_EXERCISE_REMINDER_WITHOUT_FORM',\n  EarlyExerciseReminderWithForm = 'EARLY_EXERCISE_REMINDER_WITH_FORM',\n  EmployeePortalWelcome = 'EMPLOYEE_PORTAL_WELCOME',\n  ExerciseRequestApproval = 'EXERCISE_REQUEST_APPROVAL',\n  FreeCaptableUpload = 'FREE_CAPTABLE_UPLOAD',\n  MilestoneReminder = 'MILESTONE_REMINDER',\n  NewDefaultTemplate = 'NEW_DEFAULT_TEMPLATE',\n  NewMessageNotification = 'NEW_MESSAGE_NOTIFICATION',\n  NewReplyNotification = 'NEW_REPLY_NOTIFICATION',\n  Request_409A = 'REQUEST_409A',\n  SendKudos = 'SEND_KUDOS',\n  UserInvite = 'USER_INVITE',\n  UserInviteReminder = 'USER_INVITE_REMINDER',\n  VestingPlanOfferInvite = 'VESTING_PLAN_OFFER_INVITE'\n}\n\nexport type DashboardEsopAggregate = {\n  __typename?: 'DashboardEsopAggregate';\n  allocated?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  exercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  granted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  numberOfEsops?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalOptions?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  unallocated?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type DashboardOwnership = {\n  __typename?: 'DashboardOwnership';\n  numberOfStakeholders?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  sharetypeSymbols?: Maybe<Array<Maybe<Scalars['CleanString']['output']>>>;\n  topOptionholders?: Maybe<Array<Maybe<ShareholderOwnership>>>;\n  topShareholders?: Maybe<Array<Maybe<ShareholderOwnership>>>;\n  totalOptions?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalShares?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalUnallocatedOptions?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  valuation?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type DashboardSecurities = {\n  __typename?: 'DashboardSecurities';\n  numOptionholders?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  numRsuholders?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  numShareholders?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  numStakeholders?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalOptions?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalRsus?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalShares?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type DashboardStakeholder = {\n  __typename?: 'DashboardStakeholder';\n  name?: Maybe<Scalars['String']['output']>;\n  ownership?: Maybe<Scalars['CakeDecimal']['output']>;\n  securities?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  synthetic?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type DashboardStatistics = {\n  __typename?: 'DashboardStatistics';\n  numStakeholders?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  sharetypes?: Maybe<Array<Maybe<Scalars['CleanString']['output']>>>;\n  totalSecurities?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalShares?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  valuation?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type DashboardTopStakeholders = {\n  __typename?: 'DashboardTopStakeholders';\n  dilluted?: Maybe<Array<Maybe<DashboardStakeholder>>>;\n  undilluted?: Maybe<Array<Maybe<DashboardStakeholder>>>;\n};\n\n/**\n * mutation {\n *     declineEquityOffer(\n *         offer: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type DeclineEquityOffer = {\n  __typename?: 'DeclineEquityOffer';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     declineNotesOffer (\n *         offer: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type DeclineNotesOffer = {\n  __typename?: 'DeclineNotesOffer';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type DeclineShareTransferOffer = {\n  __typename?: 'DeclineShareTransferOffer';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type DeleteCakeGroup = {\n  __typename?: 'DeleteCakeGroup';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n *\n *     # This mutation deletes a document\n *\n *     mutation Example {\n *       deleteDocument(\n *           documents: [\"34543505-7c7f-4127-bef8-a4d1bc3ce007\"]\n *       ) {\n *             ok\n *         }\n *     }\n *\n */\nexport type DeleteDocument = {\n  __typename?: 'DeleteDocument';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     deleteEquityRound(\n *         round: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type DeleteEquityRound = {\n  __typename?: 'DeleteEquityRound';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     deleteEquityRoundOffer(\n *         offer: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type DeleteEquityRoundOffer = {\n  __typename?: 'DeleteEquityRoundOffer';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     deleteNotesRound (\n *         round: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type DeleteNotesRound = {\n  __typename?: 'DeleteNotesRound';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     deleteNotesRoundTemplate (\n *         round: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type DeleteNotesRoundTemplate = {\n  __typename?: 'DeleteNotesRoundTemplate';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n *\n *     # This mutation deletes an officeholder. Ensure officeholderId\n *     # provided exists and user running the query is an Officeholder.\n *\n *     mutation Example {\n *         deleteOfficeholder (officeholder: \"f3a5cddd-a8f0-45a1-b696-073616228bc6\")\n *         { organisation  { id } }\n *     }\n *\n *\n */\nexport type DeleteOfficeholder = {\n  __typename?: 'DeleteOfficeholder';\n  officeholder?: Maybe<Officeholder>;\n  organisation?: Maybe<Organisation>;\n};\n\nexport type DeleteShareTransferOffer = {\n  __typename?: 'DeleteShareTransferOffer';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type DeleteShareTransferRound = {\n  __typename?: 'DeleteShareTransferRound';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type DeleteShareTransferRoundTemplate = {\n  __typename?: 'DeleteShareTransferRoundTemplate';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n *\n *     # This mutation deletes a sharetype. Ensure sharetypeId\n *     # provided exists and user running the query is an Officeholder.\n *\n *     mutation Example {\n *             deleteSharetype (\n *                 sharetype: \"f3a5cddd-a8f0-45a1-b696-073616228bc6\"\n *             ) { ok }\n *         }\n *\n *\n */\nexport type DeleteSharetype = {\n  __typename?: 'DeleteSharetype';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     deleteValuation (\n *         valuation: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type DeleteValuation = {\n  __typename?: 'DeleteValuation';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/** Debugging information for the current query. */\nexport type DjangoDebug = {\n  __typename?: 'DjangoDebug';\n  /** Raise exceptions for this API query. */\n  exceptions?: Maybe<Array<Maybe<DjangoDebugException>>>;\n  /** Executed SQL queries for this API query. */\n  sql?: Maybe<Array<Maybe<DjangoDebugSql>>>;\n};\n\n/** Represents a single exception raised. */\nexport type DjangoDebugException = {\n  __typename?: 'DjangoDebugException';\n  /** The class of the exception */\n  excType: Scalars['String']['output'];\n  /** The message of the exception */\n  message: Scalars['String']['output'];\n  /** The stack trace */\n  stack: Scalars['String']['output'];\n};\n\n/** Represents a single database query made to a Django managed DB. */\nexport type DjangoDebugSql = {\n  __typename?: 'DjangoDebugSQL';\n  /** The Django database alias (e.g. 'default'). */\n  alias: Scalars['String']['output'];\n  /** Duration of this database query in seconds. */\n  duration: Scalars['Float']['output'];\n  /** Postgres connection encoding if available. */\n  encoding?: Maybe<Scalars['String']['output']>;\n  /** Whether this database query was a SELECT. */\n  isSelect: Scalars['Boolean']['output'];\n  /** Whether this database query took more than 10 seconds. */\n  isSlow: Scalars['Boolean']['output'];\n  /** Postgres isolation level if available. */\n  isoLevel?: Maybe<Scalars['String']['output']>;\n  /** JSON encoded database query parameters. */\n  params: Scalars['String']['output'];\n  /** The raw SQL of this query, without params. */\n  rawSql: Scalars['String']['output'];\n  /** The actual SQL sent to this database. */\n  sql?: Maybe<Scalars['String']['output']>;\n  /** Start time of this database query. */\n  startTime: Scalars['Float']['output'];\n  /** Stop time of this database query. */\n  stopTime: Scalars['Float']['output'];\n  /** Postgres transaction ID if available. */\n  transId?: Maybe<Scalars['String']['output']>;\n  /** Postgres transaction status if available. */\n  transStatus?: Maybe<Scalars['String']['output']>;\n  /** The type of database being used (e.g. postrgesql, mysql, sqlite). */\n  vendor: Scalars['String']['output'];\n};\n\nexport type Document = {\n  __typename?: 'Document';\n  access?: Maybe<Array<Maybe<DocumentAccessType>>>;\n  boardapprovalSet: Array<BoardApprovalType>;\n  cakemessageSet: Array<CakeMessageType>;\n  certificateNumber?: Maybe<Scalars['Int']['output']>;\n  children: Array<Document>;\n  contractLink?: Maybe<Scalars['String']['output']>;\n  contractProvider?: Maybe<Scalars['String']['output']>;\n  contractType?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  /** Offer Letter template used by this Esop */\n  esopGroupOfferLetterTemplate: Array<EsopOfferGroup>;\n  /** Plan Rules template used by this Esop */\n  esopGroupPlanRulesTemplate: Array<EsopOfferGroup>;\n  /** Offer Letter template used by this ESS */\n  essGroupOfferLetterTemplate: Array<EssOfferGroup>;\n  /** Plan Rules template used by this ESS */\n  essGroupPlanRulesTemplate: Array<EssOfferGroup>;\n  extension?: Maybe<Scalars['String']['output']>;\n  /** Supported formats: PDF, DOC, DOCX, IMG, PNG or JPG */\n  file?: Maybe<Scalars['String']['output']>;\n  fileCount?: Maybe<Scalars['Int']['output']>;\n  folderCount?: Maybe<Scalars['Int']['output']>;\n  /** Offer Letter template used by this FOUNDERVESTING */\n  foundervestingGroupOfferLetterTemplate: Array<FounderVestingOfferGroupOutputType>;\n  /** Plan Rules template used by this FOUNDERVESTING */\n  foundervestingGroupPlanRulesTemplate: Array<FounderVestingOfferGroupOutputType>;\n  groups?: Maybe<Array<Maybe<CakeGroupType>>>;\n  historical409aSet: Array<Historical409AType>;\n  id: Scalars['UUID']['output'];\n  /** Automatically created folders cannot be moved. */\n  isSystem: Scalars['Boolean']['output'];\n  modified: Scalars['DateTime']['output'];\n  name?: Maybe<Scalars['String']['output']>;\n  organisation: Organisation;\n  parent?: Maybe<Document>;\n  path?: Maybe<Array<Maybe<Document>>>;\n  /** Offer Letter template used by this RSU */\n  rsuGroupOfferLetterTemplate: Array<RsuOfferGroupOutputType>;\n  /** Plan Rules template used by this RSU */\n  rsuGroupPlanRulesTemplate: Array<RsuOfferGroupOutputType>;\n  /** The contract under analysis */\n  scanbotdocumentSet: Array<ScanbotDocumentType>;\n  shareholders?: Maybe<Array<Maybe<Shareholder>>>;\n  signatureEmailBody?: Maybe<Scalars['String']['output']>;\n  signatureEmailSubject?: Maybe<Scalars['String']['output']>;\n  signatures?: Maybe<Array<Maybe<Signature>>>;\n  signingEnvelopeId?: Maybe<Scalars['String']['output']>;\n  signingLink?: Maybe<Scalars['String']['output']>;\n  status?: Maybe<Scalars['String']['output']>;\n  /** The type of a document, eg. template, processing (eg. waiting for signatures) or file (eg. downloadable pdf) */\n  type: DocumentsDocumentTypeChoices;\n  usedIn?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n  user: UserType;\n  /** Offer Letter template used by this WARRANT */\n  warrantGroupOfferLetterTemplate: Array<WarrantOfferGroupOutputType>;\n  /** Plan Rules template used by this WARRANT */\n  warrantGroupPlanRulesTemplate: Array<WarrantOfferGroupOutputType>;\n};\n\nexport type DocumentAccessType = {\n  __typename?: 'DocumentAccessType';\n  avatar?: Maybe<Scalars['String']['output']>;\n  email?: Maybe<Scalars['String']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  isDirectPermission?: Maybe<Scalars['Boolean']['output']>;\n  isShareholder?: Maybe<Scalars['Boolean']['output']>;\n  name?: Maybe<Scalars['String']['output']>;\n};\n\n/** An enumeration. */\nexport enum DocumentsDocumentTypeChoices {\n  /** FILE */\n  File = 'FILE',\n  /** FOLDER */\n  Folder = 'FOLDER',\n  /** PROCESSING */\n  Processing = 'PROCESSING',\n  /** TEMPLATE */\n  Template = 'TEMPLATE'\n}\n\n/** An enumeration. */\nexport enum DocumentsScanbotDocumentStatusChoices {\n  /** Error */\n  Error = 'ERROR',\n  /** Processing */\n  Processing = 'PROCESSING',\n  /** Success */\n  Success = 'SUCCESS'\n}\n\nexport type DraftMessagePayloadType = {\n  __typename?: 'DraftMessagePayloadType';\n  groups?: Maybe<Array<Maybe<DraftMessageTargetType>>>;\n  shareholders?: Maybe<Array<Maybe<DraftMessageTargetType>>>;\n};\n\nexport type DraftMessageTargetType = {\n  __typename?: 'DraftMessageTargetType';\n  id?: Maybe<Scalars['String']['output']>;\n  name?: Maybe<Scalars['String']['output']>;\n};\n\n/**\n * mutation {\n *         editEquityRound (\n *             round: \"00000000-0000-0000-0000-000000000000\"\n *         ) { ok }\n * }\n */\nexport type EditEquityRound = {\n  __typename?: 'EditEquityRound';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *         editNotesRound (\n *             round: \"00000000-0000-0000-0000-000000000000\"\n *         ) { ok }\n * }\n */\nexport type EditNotesRound = {\n  __typename?: 'EditNotesRound';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type EditShareTransferOffer = {\n  __typename?: 'EditShareTransferOffer';\n  transferOffer?: Maybe<ShareTransferOfferType>;\n};\n\nexport type EditShareTransferRound = {\n  __typename?: 'EditShareTransferRound';\n  transferRound?: Maybe<ShareTransferRoundType>;\n};\n\nexport type EeCompanyDetailsField = {\n  __typename?: 'EeCompanyDetailsField';\n  brc?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  registeredAddress?: Maybe<InternationalAddressField>;\n};\n\nexport type EeCompanyDetailsInput = {\n  brc: Scalars['CleanString']['input'];\n  registeredAddress?: InputMaybe<AddressInput>;\n};\n\nexport type EmailSenderType = {\n  __typename?: 'EmailSenderType';\n  created: Scalars['DateTime']['output'];\n  entryType: SeEmailSenderEntryTypeChoices;\n  expire?: Maybe<Scalars['Date']['output']>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  payload: Scalars['JSONString']['output'];\n  payloadInviteEmail?: Maybe<Scalars['String']['output']>;\n  payloadPosition?: Maybe<Scalars['String']['output']>;\n  payloadRole?: Maybe<Scalars['String']['output']>;\n  sender: UserType;\n};\n\nexport type EmployeeDataInput = {\n  level: Scalars['CleanString']['input'];\n  role: Scalars['CleanString']['input'];\n};\n\nexport type EmployeeDataType = {\n  __typename?: 'EmployeeDataType';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  level: SeEmployeeDataLevelChoices;\n  modified: Scalars['DateTime']['output'];\n  role: SeEmployeeDataRoleChoices;\n  shareholder: Shareholder;\n};\n\nexport type EquityModelDataInputType = {\n  notes?: InputMaybe<Array<InputMaybe<NoteConversionSimulationInputType>>>;\n  rounds?: InputMaybe<Array<InputMaybe<EquityRoundInputType>>>;\n};\n\nexport type EquityModelDataOutputType = {\n  __typename?: 'EquityModelDataOutputType';\n  notes?: Maybe<Array<Maybe<NoteConversionSimulationOutputType>>>;\n  rounds?: Maybe<Array<Maybe<EquityRoundOutputType>>>;\n};\n\nexport type EquityModelOutputType = {\n  __typename?: 'EquityModelOutputType';\n  conversionMethodology?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modelData: EquityModelDataOutputType;\n  modified: Scalars['DateTime']['output'];\n  name: Scalars['String']['output'];\n  /** Organisation that the saved model belongs to */\n  organisation: Organisation;\n  /** Version of the saved model and respective payload data */\n  version: Scalars['Int']['output'];\n};\n\nexport type EquityModelRoundInvestorOutputType = {\n  __typename?: 'EquityModelRoundInvestorOutputType';\n  investment: Scalars['Float']['output'];\n  name: Scalars['String']['output'];\n};\n\nexport type EquityModelRoundInvestorType = {\n  investment: Scalars['Float']['input'];\n  name: Scalars['String']['input'];\n};\n\nexport type EquityRoundInputType = {\n  convertNotes?: InputMaybe<NoteConversionEnum>;\n  equityRound: Scalars['String']['input'];\n  investmentValue?: InputMaybe<Scalars['Float']['input']>;\n  investors?: InputMaybe<Array<InputMaybe<EquityModelRoundInvestorType>>>;\n  proposedValuation: Scalars['Float']['input'];\n  roundMethodology?: InputMaybe<Scalars['String']['input']>;\n  roundType?: InputMaybe<RoundTypeEnum>;\n  topUpOptionPoolPrct: Scalars['Float']['input'];\n  topUpSequence?: InputMaybe<Scalars['String']['input']>;\n};\n\nexport enum EquityRoundNoteConversionOutputField {\n  Automatic = 'AUTOMATIC',\n  Manual = 'MANUAL',\n  NoConversion = 'NO_CONVERSION'\n}\n\nexport type EquityRoundOutputType = {\n  __typename?: 'EquityRoundOutputType';\n  convertNotes?: Maybe<EquityRoundNoteConversionOutputField>;\n  equityRound: Scalars['String']['output'];\n  investmentValue?: Maybe<Scalars['Float']['output']>;\n  investors?: Maybe<Array<Maybe<EquityModelRoundInvestorOutputType>>>;\n  proposedValuation: Scalars['Float']['output'];\n  roundMethodology?: Maybe<Scalars['String']['output']>;\n  roundType?: Maybe<EquityRoundTypeOutputField>;\n  topUpOptionPoolPrct: Scalars['Float']['output'];\n  topUpSequence?: Maybe<Scalars['String']['output']>;\n};\n\nexport enum EquityRoundTypeOutputField {\n  Both = 'BOTH',\n  Notes = 'NOTES',\n  Priced = 'PRICED'\n}\n\nexport type Esop = {\n  __typename?: 'Esop';\n  autoGenerated: Scalars['Boolean']['output'];\n  cakegroupSet: Array<CakeGroupType>;\n  commentCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  created: Scalars['DateTime']['output'];\n  documents?: Maybe<Array<Maybe<Document>>>;\n  /** ESOP this group belongs to */\n  esopoffergroupSet: Array<EsopOfferGroup>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** Name of this vesting plan */\n  name?: Maybe<Scalars['String']['output']>;\n  offerCount?: Maybe<Scalars['Int']['output']>;\n  offerGroup?: Maybe<Array<Maybe<EsopOfferGroup>>>;\n  optionPrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  options?: Maybe<Scalars['BigInt']['output']>;\n  /** Organisation this plan belongs to */\n  organisation: Organisation;\n  percentageOfOrganisationShares?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Makes it a requirement that a witness also needs to sign the offer letter. */\n  requireWitness: Scalars['Boolean']['output'];\n  totalExercised?: Maybe<Scalars['BigInt']['output']>;\n  totalGranted?: Maybe<Scalars['BigInt']['output']>;\n  totalLapsed?: Maybe<Scalars['BigInt']['output']>;\n  totalOffered?: Maybe<Scalars['BigInt']['output']>;\n  totalVested?: Maybe<Scalars['BigInt']['output']>;\n  vestingValue?: Maybe<Scalars['BigInt']['output']>;\n};\n\n/** An enumeration. */\nexport enum EsopEsopOfferExerciseExpirationStartingPointChoices {\n  /** Grant date */\n  GrantDate = 'GRANT_DATE',\n  /** Vest start date */\n  VestStartDate = 'VEST_START_DATE'\n}\n\n/** An enumeration. */\nexport enum EsopEsopOfferNextVestingMetaChoices {\n  /** Fully vesting */\n  FullyVesting = 'FULLY_VESTING',\n  /** Meeting milestone */\n  MeetingMilestone = 'MEETING_MILESTONE',\n  /** Periodic vesting */\n  PeriodicVesting = 'PERIODIC_VESTING',\n  /** Reaching cliff */\n  ReachingCliff = 'REACHING_CLIFF',\n  /** Unknown */\n  Unknown = 'UNKNOWN'\n}\n\n/** An enumeration. */\nexport enum EsopEsopOfferOptionTypeChoices {\n  /** Incentive Stock Options */\n  Iso = 'ISO',\n  /** Non-qualified Stock Options */\n  Nso = 'NSO'\n}\n\n/** An enumeration. */\nexport enum EsopEsopTransactionTypeChoices {\n  /** EXERCISED */\n  Exercised = 'EXERCISED',\n  /** GRANTED */\n  Granted = 'GRANTED',\n  /** LAPSED */\n  Lapsed = 'LAPSED',\n  /** REPRICED */\n  Repriced = 'REPRICED',\n  /** VESTED */\n  Vested = 'VESTED'\n}\n\nexport type EsopOffer = {\n  __typename?: 'EsopOffer';\n  /** Allow exercising into share vesting. */\n  allowEarlyExercise: Scalars['Boolean']['output'];\n  /** Allow option holders to nominate a trust */\n  allowNomineeTrust: Scalars['Boolean']['output'];\n  /** Whether or not the options lapse automatically on the expiration date. */\n  autoLapseOnExpirationDate?: Maybe<Scalars['Boolean']['output']>;\n  /** Whether options lapse on termination */\n  autoLapseOnTermination: Scalars['Boolean']['output'];\n  availableToExercise?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToLapse?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToPeriodicVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVestMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  boardApproval?: Maybe<BoardApprovalType>;\n  calendar?: Maybe<OfferCalendarOutputType>;\n  conversionLockDate?: Maybe<Scalars['Date']['output']>;\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  currency?: Maybe<Scalars['String']['output']>;\n  dateGranted?: Maybe<Scalars['Date']['output']>;\n  /** Disclosure period in days */\n  disclosurePeriodDays: Scalars['Int']['output'];\n  /** True means sending regular vesting emails to investor */\n  emailsOn: Scalars['Boolean']['output'];\n  /** ESOP offer */\n  esopofferpauseeventSet: Array<EsopOfferPauseEventType>;\n  /** ESOP offer */\n  esoptransactionSet: Array<EsopTransaction>;\n  /** ESOP offer */\n  esopvestingeventSet: Array<EsopVestingEventType>;\n  /** The date from when the time starts counting towards the expiration. */\n  exerciseExpirationStartingPoint?: Maybe<EsopEsopOfferExerciseExpirationStartingPointChoices>;\n  /** Date when options expire if not exercised */\n  exerciseExpireDate?: Maybe<Scalars['Date']['output']>;\n  /** Time based period from vested/granted where options expire if not exercised */\n  exerciseExpireTime?: Maybe<TimeSliceType>;\n  exercisePrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  exercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Holds the date when the email notification is sent. Should be null otherwise. */\n  expirationNotificationDate?: Maybe<Scalars['Date']['output']>;\n  /** The day the offer is granted (override) */\n  grantDateDefault?: Maybe<Scalars['Date']['output']>;\n  granted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Offer common fields */\n  group: EsopOfferGroup;\n  hasEarlyExercises?: Maybe<Scalars['Boolean']['output']>;\n  hasOngoingPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasScheduledPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasTransactions?: Maybe<Scalars['Boolean']['output']>;\n  id: Scalars['UUID']['output'];\n  /** The date the offer moved to READY_TO_CONFIRM_DETAILS */\n  inviteDate?: Maybe<Scalars['Date']['output']>;\n  lapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsedMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsedPeriodic?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lastEventDate?: Maybe<Scalars['Date']['output']>;\n  lastRepricingDate?: Maybe<Scalars['Date']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** The next vesting date computed daily by the calendar calculator */\n  nextVestingDate?: Maybe<Scalars['Date']['output']>;\n  /** The next vesting meta computed daily by the calendar calculator */\n  nextVestingMeta?: Maybe<EsopEsopOfferNextVestingMetaChoices>;\n  /** Offboarding settings for this offer */\n  offboardSettings?: Maybe<OffboardEventSettingsOutputType>;\n  /** Signer Offer Letter for this Esop offer */\n  offerLetter?: Maybe<Document>;\n  offerLetterOpt?: Maybe<Document>;\n  /** Template to generate the offer letter from */\n  offerLetterTemplate?: Maybe<Document>;\n  optionPrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Type of stock option offered */\n  optionType?: Maybe<EsopEsopOfferOptionTypeChoices>;\n  optionexerciserequestSet: Array<OptionExerciseRequestType>;\n  pauseEvents?: Maybe<Array<Maybe<EsopOfferPauseEventType>>>;\n  plan?: Maybe<Esop>;\n  /** Plan Rules for this Esop */\n  planRules?: Maybe<Document>;\n  /** Template to generate the Plan Rules from, or final doc */\n  planRulesTemplate?: Maybe<Document>;\n  /** Time period after termination when options can be exercised */\n  postTerminationExercisePeriod?: Maybe<TimeSliceType>;\n  /** PTEP settings for this offer */\n  ptepSettings?: Maybe<PtepSettingsOutputType>;\n  requestedToExercise?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Makes it a requirement that a witness also needs to sign the offer letter. */\n  requireWitness: Scalars['Boolean']['output'];\n  /** Determines if an email will be sent some days before the expiration. */\n  sendExpirationNotification?: Maybe<Scalars['Boolean']['output']>;\n  /** Investor/employee holder entity */\n  shareholder: Shareholder;\n  shareholderDisplayName?: Maybe<Scalars['String']['output']>;\n  shareholderOpt?: Maybe<Shareholder>;\n  sharetype?: Maybe<Sharetype>;\n  softStatus?: Maybe<Scalars['String']['output']>;\n  status?: Maybe<Scalars['String']['output']>;\n  /** Date when the reminder to lapse options was sent. If there is no date, no reminder was sent. */\n  terminationLapseReminderDate?: Maybe<Scalars['DateTime']['output']>;\n  totalCliffDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalGranted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalPeriodicDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  valueOfClassOfShare?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestStartDate?: Maybe<Scalars['Date']['output']>;\n  vestableMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestablePeriodic?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestedMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestingEvents?: Maybe<Array<Maybe<EsopVestingEventType>>>;\n};\n\nexport type EsopOfferApprovalItem = {\n  __typename?: 'EsopOfferApprovalItem';\n  id?: Maybe<Scalars['UUID']['output']>;\n  shareholderDisplayName?: Maybe<Scalars['String']['output']>;\n  vestStartDate?: Maybe<Scalars['Date']['output']>;\n  vestingValue?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type EsopOfferBulkEntryInputType = {\n  administrativeArea1?: InputMaybe<Scalars['String']['input']>;\n  administrativeArea2?: InputMaybe<Scalars['String']['input']>;\n  allowTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  autoGrant?: InputMaybe<Scalars['Boolean']['input']>;\n  conversionLockEvent?: InputMaybe<Scalars['CleanString']['input']>;\n  country?: InputMaybe<Scalars['String']['input']>;\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  exerciseExpireDate?: InputMaybe<Scalars['Date']['input']>;\n  exerciseExpireTime?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  exercisePrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  grantDate?: InputMaybe<Scalars['Date']['input']>;\n  line1?: InputMaybe<Scalars['String']['input']>;\n  line2?: InputMaybe<Scalars['String']['input']>;\n  line3?: InputMaybe<Scalars['String']['input']>;\n  locality?: InputMaybe<Scalars['String']['input']>;\n  name: Scalars['CleanString']['input'];\n  optionPrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  optionType?: InputMaybe<Scalars['CleanString']['input']>;\n  postcode?: InputMaybe<Scalars['String']['input']>;\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n  vestingEvents: Array<InputMaybe<VestingEventInputType>>;\n};\n\nexport type EsopOfferGroup = {\n  __typename?: 'EsopOfferGroup';\n  /** Allow exercising into share vesting. */\n  allowEarlyExercise: Scalars['Boolean']['output'];\n  /** Allow offer holders to nominate a trust */\n  allowNomineeTrust: Scalars['Boolean']['output'];\n  autoGenerated: Scalars['Boolean']['output'];\n  autoLapseOnExpirationDate?: Maybe<Scalars['Boolean']['output']>;\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  currency?: Maybe<Scalars['String']['output']>;\n  defaultExerciseExpireTime?: Maybe<TimeSliceType>;\n  /** Default Offer Letter template used by this plan */\n  defaultOfferLetterTemplate?: Maybe<Document>;\n  /** Default Plan Rules template used by this plan */\n  defaultPlanRulesTemplate?: Maybe<Document>;\n  /** Directors Resolution used by this Esop */\n  directorsResolution?: Maybe<Document>;\n  /** Directors Resolution template used by this Esop */\n  directorsResolutionTemplate?: Maybe<Document>;\n  /** Disclosure period in days */\n  disclosurePeriodDays: Scalars['Int']['output'];\n  /** Offer common fields */\n  esopofferSet: Array<EsopOffer>;\n  exerciseExpirationStartingPoint?: Maybe<Scalars['String']['output']>;\n  /** Time based period from vested/granted where options expire if not exercised */\n  exerciseExpireTime?: Maybe<TimeSliceType>;\n  exercisePrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  groupCurrency?: Maybe<Scalars['String']['output']>;\n  id: Scalars['UUID']['output'];\n  isEditable?: Maybe<Scalars['Boolean']['output']>;\n  modified: Scalars['DateTime']['output'];\n  offerAcceptedCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  offerCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Offer Letter template used by this Esop */\n  offerLetterTemplate: Array<Document>;\n  optionPrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** ESOP this group belongs to */\n  plan: Esop;\n  /** Plan Rules template used by this Esop */\n  planRulesTemplate: Array<Document>;\n  /** Time period after termination when options can be exercised */\n  postTerminationExercisePeriod?: Maybe<TimeSliceType>;\n  /** PTEP settings for offers in this group */\n  ptepSettings?: Maybe<PtepSettingsOutputType>;\n  /** Require board approval before sending offers */\n  requireBoardApproval: Scalars['Boolean']['output'];\n  /** List of restrictions on underlying shares */\n  restrictionsOnShares?: Maybe<Array<Scalars['String']['output']>>;\n  sendExpirationNotification?: Maybe<Scalars['Boolean']['output']>;\n  /** Shareholders Resolution used by this Esop */\n  shareholdersResolution?: Maybe<Document>;\n  /** Shareholders Resolution template used by this Esop */\n  shareholdersResolutionTemplate?: Maybe<Document>;\n  sharetype?: Maybe<Sharetype>;\n  totalExercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalGranted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalLapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalOffered?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalVested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  valueOfClassOfShare?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type EsopOfferInputType = {\n  allowEarlyExercise?: InputMaybe<Scalars['Boolean']['input']>;\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  autoLapseOnExpirationDate?: InputMaybe<Scalars['Boolean']['input']>;\n  conversionLockEvent?: InputMaybe<Scalars['CleanString']['input']>;\n  currency?: InputMaybe<Scalars['String']['input']>;\n  emailsOn?: InputMaybe<Scalars['Boolean']['input']>;\n  exerciseExpirationStartingPoint?: InputMaybe<Scalars['CleanString']['input']>;\n  exerciseExpireDate?: InputMaybe<Scalars['Date']['input']>;\n  exerciseExpireTime?: InputMaybe<TimeSliceInputType>;\n  exercisePrice: Scalars['CakeDecimal']['input'];\n  grantDate?: InputMaybe<Scalars['Date']['input']>;\n  optionPrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  optionType?: InputMaybe<Scalars['CleanString']['input']>;\n  postTerminationExercisePeriod?: InputMaybe<TimeSliceInputType>;\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n  sendExpirationNotification?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  useGroupCurrency?: InputMaybe<Scalars['Boolean']['input']>;\n  valueOfClassOfShare?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n  vestingEvents: Array<InputMaybe<VestingEventInputType>>;\n};\n\nexport type EsopOfferPauseEventType = {\n  __typename?: 'EsopOfferPauseEventType';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** ESOP offer */\n  offer: EsopOffer;\n  /** Date when vest pause starts */\n  pauseDate: Scalars['Date']['output'];\n  /** Date when vest pause ends */\n  resumeDate: Scalars['Date']['output'];\n  status?: Maybe<Scalars['String']['output']>;\n};\n\n/** An enumeration. */\nexport enum EsopOptionExerciseRequestStatusChoices {\n  /** Completed */\n  Completed = 'COMPLETED',\n  /** Declined */\n  Declined = 'DECLINED',\n  /** Ready to issue */\n  ReadyToIssue = 'READY_TO_ISSUE',\n  /** Ready to pay */\n  ReadyToPay = 'READY_TO_PAY',\n  /** Requested */\n  Requested = 'REQUESTED'\n}\n\nexport type EsopTransaction = {\n  __typename?: 'EsopTransaction';\n  /** True if this transaction is accelerated */\n  accelerated: Scalars['Boolean']['output'];\n  /** Document relevant for this transaction (eg: Option repricing board approval) */\n  attachment?: Maybe<Document>;\n  commentCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  created: Scalars['DateTime']['output'];\n  esopName?: Maybe<Scalars['String']['output']>;\n  exercisePrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  id: Scalars['UUID']['output'];\n  /** True is manually inserted, False if it comes from the auto-vest algo */\n  isManual: Scalars['Boolean']['output'];\n  lastComment?: Maybe<Scalars['String']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** ESOP offer */\n  offer: EsopOffer;\n  /** Transaction for this request */\n  optionexerciserequestSet: Array<OptionExerciseRequestType>;\n  /** Share transaction associated with this vesting transaction */\n  shareTransaction?: Maybe<ShareholdingTransaction>;\n  sharetype?: Maybe<Sharetype>;\n  /** Transaction date */\n  transactionDate: Scalars['Date']['output'];\n  /** Transaction type (eg. vested, exercised, lapsed */\n  type: EsopEsopTransactionTypeChoices;\n  /** Offer Vesting Event */\n  vestingEvent?: Maybe<EsopVestingEventType>;\n  vestingValue?: Maybe<Scalars['PositiveInteger']['output']>;\n};\n\nexport type EsopVestingEventType = {\n  __typename?: 'EsopVestingEventType';\n  created: Scalars['DateTime']['output'];\n  /** Offer Vesting Event */\n  esoptransactionSet: Array<EsopTransaction>;\n  eventType?: Maybe<Scalars['String']['output']>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** ESOP offer */\n  offer: EsopOffer;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  /** Event order */\n  order: Scalars['Int']['output'];\n  vestingData?: Maybe<VestingDataOutputType>;\n  /** Amount offered to investor/employee in this event */\n  vestingValue: Scalars['BigInt']['output'];\n};\n\nexport type Ess = {\n  __typename?: 'Ess';\n  autoGenerated: Scalars['Boolean']['output'];\n  cakegroupSet: Array<CakeGroupType>;\n  commentCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  created: Scalars['DateTime']['output'];\n  documents?: Maybe<Array<Maybe<Document>>>;\n  /** ESS this group belongs to */\n  essoffergroupSet: Array<EssOfferGroup>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** Name of this vesting plan */\n  name?: Maybe<Scalars['String']['output']>;\n  offerGroup?: Maybe<Array<Maybe<EssOfferGroup>>>;\n  /** Organisation this plan belongs to */\n  organisation: Organisation;\n  percentageOfOrganisationShares?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Makes it a requirement that a witness also needs to sign the offer letter. */\n  requireWitness: Scalars['Boolean']['output'];\n  totalGranted?: Maybe<Scalars['BigInt']['output']>;\n  totalLapsed?: Maybe<Scalars['BigInt']['output']>;\n  totalOffered?: Maybe<Scalars['BigInt']['output']>;\n  totalVested?: Maybe<Scalars['BigInt']['output']>;\n  vestingValue?: Maybe<Scalars['BigInt']['output']>;\n};\n\n/** An enumeration. */\nexport enum EssEssOfferNextVestingMetaChoices {\n  /** Fully vesting */\n  FullyVesting = 'FULLY_VESTING',\n  /** Meeting milestone */\n  MeetingMilestone = 'MEETING_MILESTONE',\n  /** Periodic vesting */\n  PeriodicVesting = 'PERIODIC_VESTING',\n  /** Reaching cliff */\n  ReachingCliff = 'REACHING_CLIFF',\n  /** Unknown */\n  Unknown = 'UNKNOWN'\n}\n\n/** An enumeration. */\nexport enum EssEssTransactionTypeChoices {\n  /** EXERCISED */\n  Exercised = 'EXERCISED',\n  /** GRANTED */\n  Granted = 'GRANTED',\n  /** LAPSED */\n  Lapsed = 'LAPSED',\n  /** REPRICED */\n  Repriced = 'REPRICED',\n  /** VESTED */\n  Vested = 'VESTED'\n}\n\nexport type EssOffer = {\n  __typename?: 'EssOffer';\n  /** Allow option holders to nominate a trust */\n  allowNomineeTrust: Scalars['Boolean']['output'];\n  availableToExercise?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToLapse?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToPeriodicVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVestMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Investor/employee share holding entity */\n  bareTrustTrustee?: Maybe<Shareholder>;\n  boardApproval?: Maybe<BoardApprovalType>;\n  buyBackOnTermination: Scalars['Boolean']['output'];\n  calendar?: Maybe<OfferCalendarOutputType>;\n  conversionLockDate?: Maybe<Scalars['Date']['output']>;\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  currency?: Maybe<Scalars['String']['output']>;\n  dateGranted?: Maybe<Scalars['Date']['output']>;\n  /** Disclosure period in days */\n  disclosurePeriodDays: Scalars['Int']['output'];\n  /** True means sending regular vesting emails to investor */\n  emailsOn: Scalars['Boolean']['output'];\n  essofferpauseeventSet: Array<EssOfferPauseEventType>;\n  /** ESS offer */\n  esstransactionSet: Array<EssTransaction>;\n  /** ESS offer */\n  essvestingeventSet: Array<EssVestingEventType>;\n  exercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** The day the offer is granted (override) */\n  grantDateDefault?: Maybe<Scalars['Date']['output']>;\n  granted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Offer common fields */\n  group: EssOfferGroup;\n  hasOngoingPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasScheduledPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasTransactions?: Maybe<Scalars['Boolean']['output']>;\n  id: Scalars['UUID']['output'];\n  /** The date the offer moved to READY_TO_CONFIRM_DETAILS */\n  inviteDate?: Maybe<Scalars['Date']['output']>;\n  lapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsedMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsedPeriodic?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lastEventDate?: Maybe<Scalars['Date']['output']>;\n  lastRepricingDate?: Maybe<Scalars['Date']['output']>;\n  /** True means this offer was created by the legacy system */\n  legacy: Scalars['Boolean']['output'];\n  /** Whether the shares were paid for via a company load */\n  loanFunded: Scalars['Boolean']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** The next vesting date computed daily by the calendar calculator */\n  nextVestingDate?: Maybe<Scalars['Date']['output']>;\n  /** The next vesting meta computed daily by the calendar calculator */\n  nextVestingMeta?: Maybe<EssEssOfferNextVestingMetaChoices>;\n  /** Offboarding settings for this offer */\n  offboardSettings?: Maybe<OffboardEventSettingsOutputType>;\n  /** Signer Offer Letter for this ESS offer */\n  offerLetter?: Maybe<Document>;\n  offerLetterOpt?: Maybe<Document>;\n  /** Template to generate the offer letter from */\n  offerLetterTemplate?: Maybe<Document>;\n  pauseEvents?: Maybe<Array<Maybe<EssOfferPauseEventType>>>;\n  plan?: Maybe<Ess>;\n  /** Plan Rules for this ESS */\n  planRules?: Maybe<Document>;\n  /** Template to generate the Plan Rules from, or final doc */\n  planRulesTemplate?: Maybe<Document>;\n  /** Makes it a requirement that a witness also needs to sign the offer letter. */\n  requireWitness: Scalars['Boolean']['output'];\n  sharePrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  sharePriceReal?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Investor/employee holder entity */\n  shareholder: Shareholder;\n  shareholderDisplayName?: Maybe<Scalars['String']['output']>;\n  shareholderOpt?: Maybe<Shareholder>;\n  sharetype?: Maybe<Sharetype>;\n  softStatus?: Maybe<Scalars['String']['output']>;\n  status?: Maybe<Scalars['String']['output']>;\n  totalCliffDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalGranted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalPeriodicDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestStartDate?: Maybe<Scalars['Date']['output']>;\n  vestableMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestablePeriodic?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestedMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestingEvents?: Maybe<Array<Maybe<EssVestingEventType>>>;\n};\n\nexport type EssOfferBulkEntryInputType = {\n  administrativeArea1?: InputMaybe<Scalars['String']['input']>;\n  administrativeArea2?: InputMaybe<Scalars['String']['input']>;\n  allowTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  autoGrant?: InputMaybe<Scalars['Boolean']['input']>;\n  conversionLockEvent?: InputMaybe<Scalars['CleanString']['input']>;\n  country?: InputMaybe<Scalars['String']['input']>;\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  grantDate?: InputMaybe<Scalars['Date']['input']>;\n  line1?: InputMaybe<Scalars['String']['input']>;\n  line2?: InputMaybe<Scalars['String']['input']>;\n  line3?: InputMaybe<Scalars['String']['input']>;\n  locality?: InputMaybe<Scalars['String']['input']>;\n  name: Scalars['CleanString']['input'];\n  postcode?: InputMaybe<Scalars['String']['input']>;\n  sharePrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n  vestingEvents: Array<InputMaybe<VestingEventInputType>>;\n};\n\nexport type EssOfferGroup = {\n  __typename?: 'EssOfferGroup';\n  /** Allow offer holders to nominate a trust */\n  allowNomineeTrust: Scalars['Boolean']['output'];\n  autoGenerated: Scalars['Boolean']['output'];\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  /** Default Offer Letter template used by this plan */\n  defaultOfferLetterTemplate?: Maybe<Document>;\n  /** Default Plan Rules template used by this plan */\n  defaultPlanRulesTemplate?: Maybe<Document>;\n  /** Disclosure period in days */\n  disclosurePeriodDays: Scalars['Int']['output'];\n  /** Offer common fields */\n  essofferSet: Array<EssOffer>;\n  id: Scalars['UUID']['output'];\n  isEditable?: Maybe<Scalars['Boolean']['output']>;\n  /** Whether the shares were paid for via a company load */\n  loanFunded: Scalars['Boolean']['output'];\n  modified: Scalars['DateTime']['output'];\n  offerAcceptedCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  offerCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Offer Letter template used by this ESS */\n  offerLetterTemplate: Array<Document>;\n  /** ESS this group belongs to */\n  plan: Ess;\n  /** Plan Rules template used by this ESS */\n  planRulesTemplate: Array<Document>;\n  /** Require board approval before sending offers */\n  requireBoardApproval: Scalars['Boolean']['output'];\n  sharePrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  sharetype?: Maybe<Sharetype>;\n  totalExercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalGranted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalLapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalOffered?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalVested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type EssOfferInputType = {\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  bareTrustTrustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  conversionLockEvent?: InputMaybe<Scalars['CleanString']['input']>;\n  emailsOn?: InputMaybe<Scalars['Boolean']['input']>;\n  grantDate?: InputMaybe<Scalars['Date']['input']>;\n  loanFunded?: InputMaybe<Scalars['Boolean']['input']>;\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n  sharePrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n  vestingEvents: Array<InputMaybe<VestingEventInputType>>;\n};\n\nexport type EssOfferPauseEventType = {\n  __typename?: 'EssOfferPauseEventType';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  offer: EssOffer;\n  /** Date when vest pause starts */\n  pauseDate: Scalars['Date']['output'];\n  /** Date when vest pause ends */\n  resumeDate: Scalars['Date']['output'];\n  status?: Maybe<Scalars['String']['output']>;\n};\n\nexport type EssTransaction = {\n  __typename?: 'EssTransaction';\n  /** True if this transaction is accelerated */\n  accelerated: Scalars['Boolean']['output'];\n  /** Document relevant for this transaction (eg: Option repricing board approval) */\n  attachment?: Maybe<Document>;\n  commentCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  created: Scalars['DateTime']['output'];\n  essName?: Maybe<Scalars['String']['output']>;\n  id: Scalars['UUID']['output'];\n  /** True is manually inserted, False if it comes from the auto-vest algo */\n  isManual: Scalars['Boolean']['output'];\n  lastComment?: Maybe<Scalars['String']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** ESS offer */\n  offer: EssOffer;\n  sharePrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Share transaction associated with this vesting transaction */\n  shareTransaction?: Maybe<ShareholdingTransaction>;\n  sharetype?: Maybe<Sharetype>;\n  /** Transaction date */\n  transactionDate: Scalars['Date']['output'];\n  /** Transaction type (eg. vested, exercised, lapsed */\n  type: EssEssTransactionTypeChoices;\n  /** Offer Vesting Event */\n  vestingEvent?: Maybe<EssVestingEventType>;\n  vestingValue?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type EssVestingEventType = {\n  __typename?: 'EssVestingEventType';\n  created: Scalars['DateTime']['output'];\n  /** Offer Vesting Event */\n  esstransactionSet: Array<EssTransaction>;\n  eventType?: Maybe<Scalars['String']['output']>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** ESS offer */\n  offer: EssOffer;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  /** Event order */\n  order: Scalars['Int']['output'];\n  vestingData?: Maybe<VestingDataOutputType>;\n  /** Amount offered to investor/employee in this event */\n  vestingValue: Scalars['BigInt']['output'];\n};\n\nexport type ExchangeRateType = {\n  __typename?: 'ExchangeRateType';\n  fromCurrency?: Maybe<Scalars['String']['output']>;\n  rate?: Maybe<Scalars['CakeDecimal']['output']>;\n  toCurrency?: Maybe<Scalars['String']['output']>;\n};\n\nexport type ExerciseExpireDataInputType = {\n  autoLapseOnExpirationDate?: Scalars['Boolean']['input'];\n  exerciseExpirationStartingPoint?: Scalars['CleanString']['input'];\n  exerciseExpireTime: TimeSliceInputType;\n  sendExpirationNotification?: Scalars['Boolean']['input'];\n};\n\nexport type ExerciseOptionsEsop = {\n  __typename?: 'ExerciseOptionsEsop';\n  exerciseTransaction?: Maybe<ExerciseTransactionDataType>;\n};\n\nexport type ExerciseRequestPaymentDetailsInputType = {\n  accountName: Scalars['CleanString']['input'];\n  accountNumber: Scalars['CleanString']['input'];\n  additionalInstructions?: InputMaybe<Scalars['String']['input']>;\n  routingNumber?: InputMaybe<Scalars['String']['input']>;\n};\n\nexport type ExerciseTransactionDataType = {\n  __typename?: 'ExerciseTransactionDataType';\n  shares?: Maybe<Scalars['Int']['output']>;\n  sharetype?: Maybe<Sharetype>;\n  transactionDate?: Maybe<Scalars['Date']['output']>;\n  transactionId?: Maybe<Scalars['UUID']['output']>;\n  unpaid?: Maybe<Scalars['Decimal']['output']>;\n};\n\nexport type ExerciseWarrants = {\n  __typename?: 'ExerciseWarrants';\n  exerciseTransaction?: Maybe<ExerciseTransactionDataType>;\n};\n\nexport type FallbackPaymentDetailsType = {\n  __typename?: 'FallbackPaymentDetailsType';\n  details?: Maybe<Scalars['String']['output']>;\n};\n\n/**\n *\n *     # This mutation sets document ready.\n *\n *         mutation Example {\n *             finaliseTemplate(\n *                 document: \"8450926e-7777-9891-4345-d6a2d9694780\"\n *             ) {\n *               ok\n *             }\n *         }\n *\n */\nexport type FinaliseTemplate = {\n  __typename?: 'FinaliseTemplate';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type FounderVestingOfferGroupOutputType = {\n  __typename?: 'FounderVestingOfferGroupOutputType';\n  /** Allow offer holders to nominate a trust */\n  allowNomineeTrust: Scalars['Boolean']['output'];\n  autoGenerated: Scalars['Boolean']['output'];\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  /** Default Offer Letter template used by this plan */\n  defaultOfferLetterTemplate?: Maybe<Document>;\n  /** Default Plan Rules template used by this plan */\n  defaultPlanRulesTemplate?: Maybe<Document>;\n  /** Disclosure period in days */\n  disclosurePeriodDays: Scalars['Int']['output'];\n  /** Offer common fields */\n  foundervestingofferSet: Array<FounderVestingOfferOutputType>;\n  id: Scalars['UUID']['output'];\n  isEditable?: Maybe<Scalars['Boolean']['output']>;\n  /** Whether the shares were paid for via a company load */\n  loanFunded: Scalars['Boolean']['output'];\n  modified: Scalars['DateTime']['output'];\n  offerAcceptedCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  offerCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Offer Letter template used by this FOUNDERVESTING */\n  offerLetterTemplate: Array<Document>;\n  /** FOUNDERVESTING this group belongs to */\n  plan: FounderVestingOutputType;\n  /** Plan Rules template used by this FOUNDERVESTING */\n  planRulesTemplate: Array<Document>;\n  /** Require board approval before sending offers */\n  requireBoardApproval: Scalars['Boolean']['output'];\n  sharePrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  sharetype?: Maybe<Sharetype>;\n  totalExercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalGranted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalLapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalOffered?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalVested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type FounderVestingOfferOutputType = {\n  __typename?: 'FounderVestingOfferOutputType';\n  /** Allow option holders to nominate a trust */\n  allowNomineeTrust: Scalars['Boolean']['output'];\n  availableToExercise?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToLapse?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToPeriodicVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVestMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Investor/employee share holding entity */\n  bareTrustTrustee?: Maybe<Shareholder>;\n  boardApproval?: Maybe<BoardApprovalType>;\n  buyBackOnTermination: Scalars['Boolean']['output'];\n  calendar?: Maybe<OfferCalendarOutputType>;\n  conversionLockDate?: Maybe<Scalars['Date']['output']>;\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  currency?: Maybe<Scalars['String']['output']>;\n  dateGranted?: Maybe<Scalars['Date']['output']>;\n  /** Disclosure period in days */\n  disclosurePeriodDays: Scalars['Int']['output'];\n  /** True means sending regular vesting emails to investor */\n  emailsOn: Scalars['Boolean']['output'];\n  exercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  foundervestingofferpauseeventSet: Array<FounderVestingOfferPauseEventOutputType>;\n  /** FOUNDERVESTING offer */\n  foundervestingtransactionSet: Array<FounderVestingTransactionOutputType>;\n  /** FOUNDERVESTING offer */\n  foundervestingvestingeventSet: Array<FounderVestingVestingEventOutputType>;\n  /** The day the offer is granted (override) */\n  grantDateDefault?: Maybe<Scalars['Date']['output']>;\n  granted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Offer common fields */\n  group: FounderVestingOfferGroupOutputType;\n  /** Whether the user has downloaded the 83(b) form for this offer */\n  hasDownloaded83bForm: Scalars['Boolean']['output'];\n  hasOngoingPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasScheduledPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasTransactions?: Maybe<Scalars['Boolean']['output']>;\n  id: Scalars['UUID']['output'];\n  /** The date the offer moved to READY_TO_CONFIRM_DETAILS */\n  inviteDate?: Maybe<Scalars['Date']['output']>;\n  lapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsedMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsedPeriodic?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lastEventDate?: Maybe<Scalars['Date']['output']>;\n  lastRepricingDate?: Maybe<Scalars['Date']['output']>;\n  /** True means this offer was created by the legacy system */\n  legacy: Scalars['Boolean']['output'];\n  /** Whether the shares were paid for via a company load */\n  loanFunded: Scalars['Boolean']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** The next vesting date computed daily by the calendar calculator */\n  nextVestingDate?: Maybe<Scalars['Date']['output']>;\n  /** The next vesting meta computed daily by the calendar calculator */\n  nextVestingMeta?: Maybe<FoundervestingFounderVestingOfferNextVestingMetaChoices>;\n  /** Whether a notification fo submit the 83b form to the IRS should be sent */\n  notify83bDeadline: Scalars['Boolean']['output'];\n  /** Offboarding settings for this offer */\n  offboardSettings?: Maybe<OffboardEventSettingsOutputType>;\n  /** Signer Offer Letter for this FOUNDERVESTING offer */\n  offerLetter?: Maybe<Document>;\n  offerLetterOpt?: Maybe<Document>;\n  /** Template to generate the offer letter from */\n  offerLetterTemplate?: Maybe<Document>;\n  pauseEvents?: Maybe<Array<Maybe<FounderVestingOfferPauseEventOutputType>>>;\n  plan?: Maybe<FounderVestingOutputType>;\n  /** Plan Rules for this FOUNDERVESTING */\n  planRules?: Maybe<Document>;\n  /** Template to generate the Plan Rules from, or final doc */\n  planRulesTemplate?: Maybe<Document>;\n  /** Makes it a requirement that a witness also needs to sign the offer letter. */\n  requireWitness: Scalars['Boolean']['output'];\n  sharePrice?: Maybe<Scalars['Decimal']['output']>;\n  /** Investor/employee holder entity */\n  shareholder: Shareholder;\n  shareholderDisplayName?: Maybe<Scalars['String']['output']>;\n  shareholderOpt?: Maybe<Shareholder>;\n  sharetype?: Maybe<Sharetype>;\n  softStatus?: Maybe<Scalars['String']['output']>;\n  status?: Maybe<Scalars['String']['output']>;\n  totalCliffDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalGranted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalPeriodicDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestStartDate?: Maybe<Scalars['Date']['output']>;\n  vestableMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestablePeriodic?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestedMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestingEvents?: Maybe<Array<Maybe<FounderVestingVestingEventOutputType>>>;\n};\n\nexport type FounderVestingOfferPauseEventOutputType = {\n  __typename?: 'FounderVestingOfferPauseEventOutputType';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  offer: FounderVestingOfferOutputType;\n  /** Date when vest pause starts */\n  pauseDate: Scalars['Date']['output'];\n  /** Date when vest pause ends */\n  resumeDate: Scalars['Date']['output'];\n  status?: Maybe<Scalars['String']['output']>;\n};\n\nexport type FounderVestingOutputType = {\n  __typename?: 'FounderVestingOutputType';\n  autoGenerated: Scalars['Boolean']['output'];\n  commentCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  created: Scalars['DateTime']['output'];\n  documents?: Maybe<Array<Maybe<Document>>>;\n  /** FOUNDERVESTING this group belongs to */\n  foundervestingoffergroupSet: Array<FounderVestingOfferGroupOutputType>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** Name of this vesting plan */\n  name?: Maybe<Scalars['String']['output']>;\n  offerGroup?: Maybe<Array<Maybe<FounderVestingOfferGroupOutputType>>>;\n  /** Organisation this plan belongs to */\n  organisation: Organisation;\n  percentageOfOrganisationShares?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Makes it a requirement that a witness also needs to sign the offer letter. */\n  requireWitness: Scalars['Boolean']['output'];\n  totalGranted?: Maybe<Scalars['BigInt']['output']>;\n  totalLapsed?: Maybe<Scalars['BigInt']['output']>;\n  totalOffered?: Maybe<Scalars['BigInt']['output']>;\n  totalVested?: Maybe<Scalars['BigInt']['output']>;\n  vestingValue?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type FounderVestingTransactionOutputType = {\n  __typename?: 'FounderVestingTransactionOutputType';\n  /** True if this transaction is accelerated */\n  accelerated: Scalars['Boolean']['output'];\n  /** Document relevant for this transaction (eg: Option repricing board approval) */\n  attachment?: Maybe<Document>;\n  commentCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  /** True is manually inserted, False if it comes from the auto-vest algo */\n  isManual: Scalars['Boolean']['output'];\n  lastComment?: Maybe<Scalars['String']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** FOUNDERVESTING offer */\n  offer: FounderVestingOfferOutputType;\n  sharePrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Share transaction associated with this vesting transaction */\n  shareTransaction?: Maybe<ShareholdingTransaction>;\n  sharetype?: Maybe<Sharetype>;\n  /** Transaction date */\n  transactionDate: Scalars['Date']['output'];\n  /** Transaction type (eg. vested, exercised, lapsed */\n  type: FoundervestingFounderVestingTransactionTypeChoices;\n  /** Offer Vesting Event */\n  vestingEvent?: Maybe<FounderVestingVestingEventOutputType>;\n  vestingValue?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type FounderVestingVestingEventOutputType = {\n  __typename?: 'FounderVestingVestingEventOutputType';\n  created: Scalars['DateTime']['output'];\n  eventType?: Maybe<Scalars['String']['output']>;\n  /** Offer Vesting Event */\n  foundervestingtransactionSet: Array<FounderVestingTransactionOutputType>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** FOUNDERVESTING offer */\n  offer: FounderVestingOfferOutputType;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  /** Event order */\n  order: Scalars['Int']['output'];\n  vestingData?: Maybe<VestingDataOutputType>;\n  /** Amount offered to investor/employee in this event */\n  vestingValue: Scalars['BigInt']['output'];\n};\n\n/** An enumeration. */\nexport enum FoundervestingFounderVestingOfferNextVestingMetaChoices {\n  /** Fully vesting */\n  FullyVesting = 'FULLY_VESTING',\n  /** Meeting milestone */\n  MeetingMilestone = 'MEETING_MILESTONE',\n  /** Periodic vesting */\n  PeriodicVesting = 'PERIODIC_VESTING',\n  /** Reaching cliff */\n  ReachingCliff = 'REACHING_CLIFF',\n  /** Unknown */\n  Unknown = 'UNKNOWN'\n}\n\n/** An enumeration. */\nexport enum FoundervestingFounderVestingTransactionTypeChoices {\n  /** EXERCISED */\n  Exercised = 'EXERCISED',\n  /** GRANTED */\n  Granted = 'GRANTED',\n  /** LAPSED */\n  Lapsed = 'LAPSED',\n  /** REPRICED */\n  Repriced = 'REPRICED',\n  /** VESTED */\n  Vested = 'VESTED'\n}\n\nexport type GbCompanyDetailsField = {\n  __typename?: 'GbCompanyDetailsField';\n  created: Scalars['DateTime']['output'];\n  crn?: Maybe<Scalars['String']['output']>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  registeredAddress?: Maybe<InternationalAddressField>;\n};\n\nexport type GbCompanyDetailsInput = {\n  crn: Scalars['CleanString']['input'];\n  registeredAddress?: InputMaybe<AddressInput>;\n};\n\n/**\n * mutation generateShareCertificatesFromHoldings(\n *     $shareholderIds: [ShareholderCakeType]!,\n *     $certificateNumber: Int!,\n *     $selectionOrganisationId: OrganisationCakeType,\n *     $selectionSearch: String,\n *     $notifyShareholder: Boolean,\n *     $disclaimersBySharetype: [SharetypeDisclaimerInputType!]\n * ) {\n *     generateShareCertificatesFromHoldings (\n *         shareholders: $shareholderIds,\n *         certificateNumber: $certificateNumber,\n *         organisation: $selectionOrganisationId,\n *         selectionSearch: $selectionSearch,\n *         notifyShareholder: $notifyShareholder,\n *         disclaimersBySharetype: $disclaimersBySharetype\n *     ) {\n *         lastCertificateNumber\n *     }\n * }\n */\nexport type GenerateShareCertificates = {\n  __typename?: 'GenerateShareCertificates';\n  lastCertificateNumber?: Maybe<Scalars['Int']['output']>;\n};\n\nexport type GroupUser = {\n  __typename?: 'GroupUser';\n  avatar?: Maybe<Scalars['String']['output']>;\n  email?: Maybe<Scalars['String']['output']>;\n  name?: Maybe<Scalars['String']['output']>;\n  userId?: Maybe<Scalars['UUID']['output']>;\n  userType?: Maybe<Scalars['String']['output']>;\n};\n\nexport type GroupUserInputType = {\n  userId: Scalars['UUID']['input'];\n  userType: Scalars['String']['input'];\n};\n\nexport type GroupedFounderVestHoldingType = {\n  __typename?: 'GroupedFounderVestHoldingType';\n  availableToExercise?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToLapse?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToPeriodicVest?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToVest?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToVestMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  conversionLockDate?: Maybe<Scalars['Date']['output']>;\n  exercised?: Maybe<Scalars['CakeDecimal']['output']>;\n  granted?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsed?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsedMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  offer?: Maybe<FounderVestingOfferOutputType>;\n  offerGroup?: Maybe<FounderVestingOfferGroupOutputType>;\n  offerGroupId?: Maybe<Scalars['UUID']['output']>;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  plan?: Maybe<FounderVestingOutputType>;\n  planId?: Maybe<Scalars['UUID']['output']>;\n  sharetype?: Maybe<Sharetype>;\n  sharetypeId?: Maybe<Scalars['UUID']['output']>;\n  vestableMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestablePeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  vested?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestedMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type GroupedNoteholdingType = {\n  __typename?: 'GroupedNoteholdingType';\n  notetype?: Maybe<Scalars['String']['output']>;\n  totalInvested?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalNotes?: Maybe<Scalars['Int']['output']>;\n};\n\nexport type GroupedOptionholdingType = {\n  __typename?: 'GroupedOptionholdingType';\n  availableToExercise?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToLapse?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToPeriodicVest?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToVest?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToVestMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  conversionLockDate?: Maybe<Scalars['Date']['output']>;\n  exercised?: Maybe<Scalars['CakeDecimal']['output']>;\n  granted?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsed?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsedMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  offer?: Maybe<EsopOffer>;\n  offerGroup?: Maybe<EsopOfferGroup>;\n  offerGroupId?: Maybe<Scalars['UUID']['output']>;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  plan?: Maybe<Esop>;\n  planId?: Maybe<Scalars['UUID']['output']>;\n  sharetype?: Maybe<Sharetype>;\n  sharetypeId?: Maybe<Scalars['UUID']['output']>;\n  vestableMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestablePeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  vested?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestedMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type GroupedRsuHoldingType = {\n  __typename?: 'GroupedRsuHoldingType';\n  availableToExercise?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToLapse?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToPeriodicVest?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToVest?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToVestMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  conversionLockDate?: Maybe<Scalars['Date']['output']>;\n  exercised?: Maybe<Scalars['CakeDecimal']['output']>;\n  granted?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsed?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsedMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  offer?: Maybe<RsuOfferOutputType>;\n  offerGroup?: Maybe<RsuOfferGroupOutputType>;\n  offerGroupId?: Maybe<Scalars['UUID']['output']>;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  plan?: Maybe<RsuOutputType>;\n  planId?: Maybe<Scalars['UUID']['output']>;\n  sharetype?: Maybe<Sharetype>;\n  sharetypeId?: Maybe<Scalars['UUID']['output']>;\n  vestableMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestablePeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  vested?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestedMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type GroupedShareVestHoldingType = {\n  __typename?: 'GroupedShareVestHoldingType';\n  availableToExercise?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToLapse?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToPeriodicVest?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToVest?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToVestMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  conversionLockDate?: Maybe<Scalars['Date']['output']>;\n  exercised?: Maybe<Scalars['CakeDecimal']['output']>;\n  granted?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsed?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsedMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  offer?: Maybe<EssOffer>;\n  offerGroup?: Maybe<EssOfferGroup>;\n  offerGroupId?: Maybe<Scalars['UUID']['output']>;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  plan?: Maybe<Ess>;\n  planId?: Maybe<Scalars['UUID']['output']>;\n  sharetype?: Maybe<Sharetype>;\n  sharetypeId?: Maybe<Scalars['UUID']['output']>;\n  vestableMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestablePeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  vested?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestedMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type GroupedShareholdingInTrustType = {\n  __typename?: 'GroupedShareholdingInTrustType';\n  beneficiary: Shareholder;\n  id: Scalars['UUID']['output'];\n  investment?: Maybe<Scalars['CakeDecimal']['output']>;\n  investmentUnpaid?: Maybe<Scalars['CakeDecimal']['output']>;\n  realShares?: Maybe<Scalars['BigInt']['output']>;\n  shares: Scalars['BigInt']['output'];\n  sharetype: Sharetype;\n  totalInvested?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalPaidInIssuance?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalShares?: Maybe<Scalars['BigInt']['output']>;\n  totalTransferPaid?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalTransferReceived?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalUnpaid?: Maybe<Scalars['CakeDecimal']['output']>;\n  trustee: Shareholder;\n};\n\nexport type GroupedShareholdingType = {\n  __typename?: 'GroupedShareholdingType';\n  id: Scalars['UUID']['output'];\n  investment?: Maybe<Scalars['CakeDecimal']['output']>;\n  investmentUnpaid?: Maybe<Scalars['CakeDecimal']['output']>;\n  realShares?: Maybe<Scalars['BigInt']['output']>;\n  shareholder: Shareholder;\n  shares: Scalars['BigInt']['output'];\n  sharetype: Sharetype;\n  totalInvested?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalPaidInIssuance?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalShares?: Maybe<Scalars['BigInt']['output']>;\n  totalTransferPaid?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalTransferReceived?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalUnpaid?: Maybe<Scalars['CakeDecimal']['output']>;\n  unvestedShares?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type GroupedWarrantHoldingType = {\n  __typename?: 'GroupedWarrantHoldingType';\n  availableToExercise?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToLapse?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToPeriodicVest?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToVest?: Maybe<Scalars['CakeDecimal']['output']>;\n  availableToVestMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  conversionLockDate?: Maybe<Scalars['Date']['output']>;\n  exercised?: Maybe<Scalars['CakeDecimal']['output']>;\n  granted?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsed?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsedMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  lapsedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  offer?: Maybe<WarrantOfferOutputType>;\n  offerGroup?: Maybe<WarrantOfferGroupOutputType>;\n  offerGroupId?: Maybe<Scalars['UUID']['output']>;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  plan?: Maybe<WarrantOutputType>;\n  planId?: Maybe<Scalars['UUID']['output']>;\n  sharetype?: Maybe<Sharetype>;\n  sharetypeId?: Maybe<Scalars['UUID']['output']>;\n  vestableMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestablePeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  vested?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestedMilestone?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type Historical409AType = {\n  __typename?: 'Historical409AType';\n  created: Scalars['DateTime']['output'];\n  documentation?: Maybe<Document>;\n  /** Fair Market Value as defined by the 409A valuation */\n  fairMarketValue: Scalars['Decimal']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  /** Date of 409A */\n  valuationDate: Scalars['Date']['output'];\n};\n\n/** An enumeration. */\nexport enum HoldingsType {\n  Beneficiaries = 'BENEFICIARIES',\n  Contacts = 'CONTACTS',\n  Noteholders = 'NOTEHOLDERS',\n  Optionholders = 'OPTIONHOLDERS',\n  Rsuholders = 'RSUHOLDERS',\n  Shareholders = 'SHAREHOLDERS',\n  ShareVestHolders = 'SHARE_VEST_HOLDERS'\n}\n\nexport type HomeEntrypointType = {\n  __typename?: 'HomeEntrypointType';\n  hasDocuments?: Maybe<Scalars['Boolean']['output']>;\n  hasPendingOffers?: Maybe<Scalars['Boolean']['output']>;\n  hasSecurities?: Maybe<Scalars['Boolean']['output']>;\n  hasUnreadMessages?: Maybe<Scalars['Boolean']['output']>;\n  hasVisibleValuation?: Maybe<Scalars['Boolean']['output']>;\n  ongoingCliff?: Maybe<Scalars['UUID']['output']>;\n  ongoingVestingList?: Maybe<Array<Maybe<AnyVestingOffer>>>;\n};\n\n/** An enumeration. */\nexport enum IdentifierType {\n  Abn = 'ABN',\n  Acn = 'ACN',\n  Bn = 'BN',\n  Brc = 'BRC',\n  Cin = 'CIN',\n  Crn = 'CRN',\n  Ein = 'EIN',\n  Nzbn = 'NZBN',\n  Other = 'OTHER',\n  Uen = 'UEN'\n}\n\nexport enum IdentifierTypeOutputField {\n  Abn = 'ABN',\n  Acn = 'ACN',\n  Bn = 'BN',\n  Brc = 'BRC',\n  Cin = 'CIN',\n  Crn = 'CRN',\n  Ein = 'EIN',\n  Nzbn = 'NZBN',\n  Other = 'OTHER',\n  Uen = 'UEN'\n}\n\nexport type InCompanyDetailsField = {\n  __typename?: 'InCompanyDetailsField';\n  cin?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  registeredAddress?: Maybe<InternationalAddressField>;\n};\n\nexport type InCompanyDetailsInput = {\n  cin: Scalars['CleanString']['input'];\n  registeredAddress?: InputMaybe<AddressInput>;\n};\n\nexport type InboxItemType = {\n  __typename?: 'InboxItemType';\n  avatarImage?: Maybe<Scalars['String']['output']>;\n  avatarName?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  hasAttachments: Scalars['Boolean']['output'];\n  hasUnreadMessages: Scalars['Boolean']['output'];\n  id: Scalars['UUID']['output'];\n  lastMessageStatus: MessageStatus;\n  nRecipients: Scalars['PositiveIntegerOrZero']['output'];\n  organisationId: Scalars['UUID']['output'];\n  organisationName: Scalars['String']['output'];\n  subject: Scalars['String']['output'];\n  threadLength: Scalars['PositiveIntegerOrZero']['output'];\n};\n\nexport type Interest = {\n  accrualFrequency: Scalars['PositiveInteger']['input'];\n  accrualMethod: Scalars['CleanString']['input'];\n  rate: Scalars['CakeDecimal']['input'];\n};\n\nexport type InternationalAddressField = {\n  __typename?: 'InternationalAddressField';\n  administrativeArea1?: Maybe<Scalars['String']['output']>;\n  administrativeArea2?: Maybe<Scalars['String']['output']>;\n  aucompanydetails?: Maybe<AuCompanyDetailsField>;\n  cacompanydetails?: Maybe<CaCompanyDetailsField>;\n  careOf?: Maybe<Scalars['String']['output']>;\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  eecompanydetails?: Maybe<EeCompanyDetailsField>;\n  gbcompanydetails?: Maybe<GbCompanyDetailsField>;\n  id: Scalars['UUID']['output'];\n  incompanydetails?: Maybe<InCompanyDetailsField>;\n  investordata?: Maybe<InvestorDataType>;\n  line1?: Maybe<Scalars['String']['output']>;\n  line2?: Maybe<Scalars['String']['output']>;\n  line3?: Maybe<Scalars['String']['output']>;\n  locality?: Maybe<Scalars['String']['output']>;\n  modified: Scalars['DateTime']['output'];\n  nzcompanydetails?: Maybe<NzCompanyDetailsField>;\n  postcode?: Maybe<Scalars['String']['output']>;\n  sgcompanydetails?: Maybe<SgCompanyDetailsField>;\n  uscompanydetails?: Maybe<UsCompanyDetailsField>;\n};\n\n/** An enumeration. */\nexport enum InternationalUsCompanyDetailsStateOfRegistrationChoices {\n  /** Alaska */\n  Ak = 'AK',\n  /** Alabama */\n  Al = 'AL',\n  /** Arkansas */\n  Ar = 'AR',\n  /** American Samoa */\n  As = 'AS',\n  /** Arizona */\n  Az = 'AZ',\n  /** California */\n  Ca = 'CA',\n  /** Colorado */\n  Co = 'CO',\n  /** Connecticut */\n  Ct = 'CT',\n  /** District Of Columbia */\n  Dc = 'DC',\n  /** Delaware */\n  De = 'DE',\n  /** Florida */\n  Fl = 'FL',\n  /** Federated States Of Micronesia */\n  Fm = 'FM',\n  /** Georgia */\n  Ga = 'GA',\n  /** Guam */\n  Gu = 'GU',\n  /** Hawaii */\n  Hi = 'HI',\n  /** Iowa */\n  Ia = 'IA',\n  /** Idaho */\n  Id = 'ID',\n  /** Illinois */\n  Il = 'IL',\n  /** Indiana */\n  In = 'IN',\n  /** Kansas */\n  Ks = 'KS',\n  /** Kentucky */\n  Ky = 'KY',\n  /** Louisiana */\n  La = 'LA',\n  /** Massachusetts */\n  Ma = 'MA',\n  /** Maryland */\n  Md = 'MD',\n  /** Maine */\n  Me = 'ME',\n  /** Marshall Islands */\n  Mh = 'MH',\n  /** Michigan */\n  Mi = 'MI',\n  /** Minnesota */\n  Mn = 'MN',\n  /** Missouri */\n  Mo = 'MO',\n  /** Northern Mariana Islands */\n  Mp = 'MP',\n  /** Mississippi */\n  Ms = 'MS',\n  /** Montana */\n  Mt = 'MT',\n  /** North Carolina */\n  Nc = 'NC',\n  /** North Dakota */\n  Nd = 'ND',\n  /** Nebraska */\n  Ne = 'NE',\n  /** New Hampshire */\n  Nh = 'NH',\n  /** New Jersey */\n  Nj = 'NJ',\n  /** New Mexico */\n  Nm = 'NM',\n  /** Nevada */\n  Nv = 'NV',\n  /** New York */\n  Ny = 'NY',\n  /** Ohio */\n  Oh = 'OH',\n  /** Oklahoma */\n  Ok = 'OK',\n  /** Oregon */\n  Or = 'OR',\n  /** Pennsylvania */\n  Pa = 'PA',\n  /** Puerto Rico */\n  Pr = 'PR',\n  /** Palau */\n  Pw = 'PW',\n  /** Rhode Island */\n  Ri = 'RI',\n  /** South Carolina */\n  Sc = 'SC',\n  /** South Dakota */\n  Sd = 'SD',\n  /** Tennessee */\n  Tn = 'TN',\n  /** Texas */\n  Tx = 'TX',\n  /** Utah */\n  Ut = 'UT',\n  /** Virginia */\n  Va = 'VA',\n  /** Virgin Islands */\n  Vi = 'VI',\n  /** Vermont */\n  Vt = 'VT',\n  /** Washington */\n  Wa = 'WA',\n  /** Wisconsin */\n  Wi = 'WI',\n  /** West Virginia */\n  Wv = 'WV',\n  /** Wyoming */\n  Wy = 'WY'\n}\n\nexport type InvestorAndEmployeeDataInput = {\n  employeeData?: InputMaybe<EmployeeDataInput>;\n  investorData: InvestorDataInput;\n};\n\nexport type InvestorDataInput = {\n  address?: InputMaybe<AddressInput>;\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  name: Scalars['CleanString']['input'];\n  phone?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\nexport type InvestorDataType = {\n  __typename?: 'InvestorDataType';\n  address?: Maybe<InternationalAddressField>;\n  companyData?: Maybe<CompanyDataType>;\n  created: Scalars['DateTime']['output'];\n  email?: Maybe<Scalars['String']['output']>;\n  id: Scalars['UUID']['output'];\n  /** holds the ordinal # of investor for joints */\n  jointIndex: Scalars['Int']['output'];\n  modified: Scalars['DateTime']['output'];\n  name: Scalars['String']['output'];\n  phone?: Maybe<Scalars['String']['output']>;\n  shareholder: Shareholder;\n};\n\n/**\n * mutation {\n *   inviteEquityOffer(\n *       offer: \"00000000-0000-0000-0000-000000000000\"\n *   ) { ok }\n * }\n */\nexport type InviteEquityOffer = {\n  __typename?: 'InviteEquityOffer';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type InviteJoinCake = {\n  __typename?: 'InviteJoinCake';\n  numInvited?: Maybe<Scalars['Int']['output']>;\n};\n\n/**\n * mutation {\n *     inviteNotesOffer (\n *         offer: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type InviteNotesOffer = {\n  __typename?: 'InviteNotesOffer';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type InviteShareTransferOffer = {\n  __typename?: 'InviteShareTransferOffer';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type InviteUsers = {\n  __typename?: 'InviteUsers';\n  invites?: Maybe<Array<Maybe<EmailSenderType>>>;\n};\n\nexport type InvitedShareholderEmailInput = {\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  id: Scalars['UUID']['input'];\n};\n\nexport type InvitedUserInput = {\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  position?: InputMaybe<Scalars['CleanString']['input']>;\n  role?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\nexport type Invoice = {\n  __typename?: 'Invoice';\n  currency?: Maybe<Scalars['String']['output']>;\n  date?: Maybe<Scalars['String']['output']>;\n  description?: Maybe<Scalars['String']['output']>;\n  invoice?: Maybe<Scalars['String']['output']>;\n  isPaid?: Maybe<Scalars['Boolean']['output']>;\n  total?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\n/**\n * mutation {\n *     issueOfferNote (\n *         offer: \"00000000-0000-0000-0000-000000000000\"\n *     ) { note { id } }\n * }\n */\nexport type IssueOfferNote = {\n  __typename?: 'IssueOfferNote';\n  note?: Maybe<Note>;\n};\n\n/**\n * mutation {\n *     issueOfferShares(\n *         offer: \"00000000-0000-0000-0000-000000000000\",\n *         certificateCount: 17\n *     ) { certificate {{ id }} shareholdingTransaction {{ shares }}  }\n * }\n */\nexport type IssueOfferShares = {\n  __typename?: 'IssueOfferShares';\n  certificate?: Maybe<Document>;\n  shareholdingTransaction?: Maybe<ShareholdingTransaction>;\n};\n\nexport type IssueSharesInput = {\n  amount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  document?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  shareType: Scalars['SharetypeCakeType']['input'];\n  shareholder: Scalars['ShareholderCakeType']['input'];\n  shares: Scalars['PositiveInteger']['input'];\n  trustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  unpaidAmount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\nexport type LapseMilestoneEntryInputType = {\n  lapseValue: Scalars['PositiveInteger']['input'];\n  vestingEvent: Scalars['UUID']['input'];\n};\n\nexport type LicenseInfoType = {\n  __typename?: 'LicenseInfoType';\n  /** Whether we can work with this customer's subscription. */\n  active: Scalars['Boolean']['output'];\n  addonsMetadata?: Maybe<Scalars['JSONString']['output']>;\n  /** Email address used for billing purposes. */\n  billingEmail?: Maybe<Scalars['String']['output']>;\n  /** Mobile number used for billing purposes. */\n  billingMobile?: Maybe<Scalars['String']['output']>;\n  /** The internal_id in Stripe subscription's metadata. */\n  cakePlan?: Maybe<SalesLicenseCakePlanChoices>;\n  /** Two-digit number representing the card's expiration month. */\n  ccExpMonth?: Maybe<Scalars['Int']['output']>;\n  /** Four-digit number representing the card's expiration year. */\n  ccExpYear?: Maybe<Scalars['Int']['output']>;\n  /** The last four digits of the card used as a payment method. */\n  ccLast4?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  delinquent?: Maybe<Scalars['Boolean']['output']>;\n  equityRaiseCount?: Maybe<Scalars['Int']['output']>;\n  esopCount?: Maybe<Scalars['Int']['output']>;\n  esopOfferCount?: Maybe<Scalars['Int']['output']>;\n  essCount?: Maybe<Scalars['Int']['output']>;\n  essOfferCount?: Maybe<Scalars['Int']['output']>;\n  globalEsopEnabled?: Maybe<Scalars['Boolean']['output']>;\n  gtCountries?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n  hasActivePurchased409a?: Maybe<Scalars['Boolean']['output']>;\n  hasActivePurchasedQsbs?: Maybe<Scalars['Boolean']['output']>;\n  /** Whether this license has pricing tweaks applied. */\n  hasCustomBaseOrPerhead: Scalars['Boolean']['output'];\n  /** Whether this license has a custom pricing deal. */\n  hasCustomDeal: Scalars['Boolean']['output'];\n  hasEquityPlansEnabled?: Maybe<Scalars['Boolean']['output']>;\n  /** Whether this subscription was paused before or not. */\n  hasPausedBefore: Scalars['Boolean']['output'];\n  hasScanbotDocuments?: Maybe<Scalars['Boolean']['output']>;\n  id: Scalars['ID']['output'];\n  internalId?: Maybe<Scalars['String']['output']>;\n  /** Date since when the license has been invalid. */\n  invalidSince?: Maybe<Scalars['DateTime']['output']>;\n  investorCount?: Maybe<Scalars['Int']['output']>;\n  /** Marks when the subscription is paused. */\n  isPaused: Scalars['Boolean']['output'];\n  /** The last forced price upgrade. */\n  lastForcedPriceUpgrade?: Maybe<Scalars['String']['output']>;\n  /** The max_investors in Stripe subscription's metadata. */\n  maxInvestors?: Maybe<Scalars['Int']['output']>;\n  modified: Scalars['DateTime']['output'];\n  oneOffAddons?: Maybe<Array<Maybe<OneOffAddon>>>;\n  organisation: Organisation;\n  override2faLock?: Maybe<Scalars['Boolean']['output']>;\n  overrideDelinquentLock?: Maybe<Scalars['Boolean']['output']>;\n  /** Date when the cake subscription renewal was attempted. */\n  renewalAttemptDate?: Maybe<Scalars['DateTime']['output']>;\n  /** Date when the cake subscription will renew. */\n  renewalDate?: Maybe<Scalars['DateTime']['output']>;\n  rsuCount?: Maybe<Scalars['Int']['output']>;\n  rsuOfferCount?: Maybe<Scalars['Int']['output']>;\n  showExpired409aBanner?: Maybe<Scalars['Boolean']['output']>;\n  /** Date when the cake plan was added to the subscription. */\n  startDate?: Maybe<Scalars['DateTime']['output']>;\n  /** Date when the subscription was canceled (if it was). */\n  subscriptionCancelDate?: Maybe<Scalars['DateTime']['output']>;\n  /** Whether everything is OK. */\n  valid: Scalars['Boolean']['output'];\n  /** The version in Stripe subscription's metadata. */\n  version?: Maybe<Scalars['Int']['output']>;\n  warrantOfferCount?: Maybe<Scalars['Int']['output']>;\n};\n\n\nexport type LicenseInfoTypeOneOffAddonsArgs = {\n  filterAddon?: InputMaybe<AddonType>;\n};\n\nexport type ListContextNoteOfferType = {\n  __typename?: 'ListContextNoteOfferType';\n  contractId?: Maybe<Scalars['String']['output']>;\n  discountRate?: Maybe<Scalars['CakeDecimal']['output']>;\n  id: Scalars['UUID']['output'];\n  interestRate?: Maybe<Scalars['CakeDecimal']['output']>;\n  issueDate?: Maybe<Scalars['Date']['output']>;\n  maturityDate?: Maybe<Scalars['Date']['output']>;\n  noteType: NoteType;\n  principal: Scalars['CakeDecimal']['output'];\n  resolutionDate?: Maybe<Scalars['Date']['output']>;\n  roundName?: Maybe<Scalars['String']['output']>;\n  shEmail?: Maybe<Scalars['String']['output']>;\n  shareholderAvatar?: Maybe<Scalars['String']['output']>;\n  shareholderConsideredInvited: Scalars['Boolean']['output'];\n  shareholderDisplayName: Scalars['String']['output'];\n  shareholderHasLoggedIn: Scalars['Boolean']['output'];\n  shareholderId: Scalars['UUID']['output'];\n  shareholderIsTrust: Scalars['Boolean']['output'];\n  shareholderSecondaryName?: Maybe<Scalars['String']['output']>;\n  shareholderType: Scalars['String']['output'];\n  softStatus: Scalars['String']['output'];\n  status: Scalars['String']['output'];\n  valuationCap?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type ListContextRsuOfferType = {\n  __typename?: 'ListContextRsuOfferType';\n  allowEarlyExercise?: Maybe<Scalars['Boolean']['output']>;\n  allowNomineeTrust?: Maybe<Scalars['Boolean']['output']>;\n  availableToExercise?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToLapse?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  boardApprovalId?: Maybe<Scalars['UUID']['output']>;\n  conversionLockEventDate?: Maybe<Scalars['Date']['output']>;\n  conversionLockEventDescription?: Maybe<Scalars['String']['output']>;\n  conversionLockEventId?: Maybe<Scalars['UUID']['output']>;\n  country?: Maybe<Scalars['String']['output']>;\n  dateGranted?: Maybe<Scalars['Date']['output']>;\n  emailsOn?: Maybe<Scalars['Boolean']['output']>;\n  exercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  grantDateDefault?: Maybe<Scalars['Date']['output']>;\n  granted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  groupId?: Maybe<Scalars['UUID']['output']>;\n  hasOngoingPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasScheduledPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  lapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  modified?: Maybe<Scalars['DateTime']['output']>;\n  offerLetterId?: Maybe<Scalars['UUID']['output']>;\n  planId?: Maybe<Scalars['UUID']['output']>;\n  requireWitness?: Maybe<Scalars['Boolean']['output']>;\n  shEmail?: Maybe<Scalars['String']['output']>;\n  shareholderAvatar?: Maybe<Scalars['String']['output']>;\n  shareholderConsideredInvited?: Maybe<Scalars['Boolean']['output']>;\n  shareholderDisplayName?: Maybe<Scalars['String']['output']>;\n  shareholderHasLoggedIn?: Maybe<Scalars['Boolean']['output']>;\n  shareholderId?: Maybe<Scalars['UUID']['output']>;\n  shareholderIsTrust?: Maybe<Scalars['Boolean']['output']>;\n  shareholderSecondaryName?: Maybe<Scalars['String']['output']>;\n  shareholderType?: Maybe<Scalars['String']['output']>;\n  softStatus?: Maybe<Scalars['String']['output']>;\n  status?: Maybe<Scalars['String']['output']>;\n  vestStartDate?: Maybe<Scalars['Date']['output']>;\n  vested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestingValue?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type ListContextShareholderType = {\n  __typename?: 'ListContextShareholderType';\n  avatar?: Maybe<Scalars['String']['output']>;\n  consideredInvited?: Maybe<Scalars['Boolean']['output']>;\n  displayName?: Maybe<Scalars['String']['output']>;\n  email?: Maybe<Scalars['String']['output']>;\n  hasLoggedIn?: Maybe<Scalars['Boolean']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  isGeneratingCertificate?: Maybe<Scalars['Boolean']['output']>;\n  isTrust?: Maybe<Scalars['Boolean']['output']>;\n  lastCertificateId?: Maybe<Scalars['UUID']['output']>;\n  lastCertificateName?: Maybe<Scalars['CleanString']['output']>;\n  secondaryName?: Maybe<Scalars['String']['output']>;\n  sharetypeHoldings?: Maybe<Array<Maybe<SharetypeHoldingType>>>;\n  stakeholderType?: Maybe<Scalars['String']['output']>;\n  totalShares?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type ListContextVestingOfferType = {\n  __typename?: 'ListContextVestingOfferType';\n  allowEarlyExercise?: Maybe<Scalars['Boolean']['output']>;\n  allowNomineeTrust?: Maybe<Scalars['Boolean']['output']>;\n  availableToExercise?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToLapse?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  boardApprovalId?: Maybe<Scalars['UUID']['output']>;\n  country?: Maybe<Scalars['String']['output']>;\n  dateGranted?: Maybe<Scalars['Date']['output']>;\n  emailsOn?: Maybe<Scalars['Boolean']['output']>;\n  exercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  grantDateDefault?: Maybe<Scalars['Date']['output']>;\n  granted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  groupId?: Maybe<Scalars['UUID']['output']>;\n  hasOngoingPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasScheduledPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  lapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  modified?: Maybe<Scalars['DateTime']['output']>;\n  offerLetterId?: Maybe<Scalars['UUID']['output']>;\n  planId?: Maybe<Scalars['UUID']['output']>;\n  requireWitness?: Maybe<Scalars['Boolean']['output']>;\n  shEmail?: Maybe<Scalars['String']['output']>;\n  shareholderAvatar?: Maybe<Scalars['String']['output']>;\n  shareholderConsideredInvited?: Maybe<Scalars['Boolean']['output']>;\n  shareholderDisplayName?: Maybe<Scalars['String']['output']>;\n  shareholderHasLoggedIn?: Maybe<Scalars['Boolean']['output']>;\n  shareholderId?: Maybe<Scalars['UUID']['output']>;\n  shareholderIsTrust?: Maybe<Scalars['Boolean']['output']>;\n  shareholderSecondaryName?: Maybe<Scalars['String']['output']>;\n  shareholderType?: Maybe<Scalars['String']['output']>;\n  softStatus?: Maybe<Scalars['String']['output']>;\n  status?: Maybe<Scalars['String']['output']>;\n  vestStartDate?: Maybe<Scalars['Date']['output']>;\n  vested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestingValue?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type ListFilterType = {\n  filterType?: InputMaybe<Scalars['String']['input']>;\n  key?: InputMaybe<Scalars['String']['input']>;\n  negate?: InputMaybe<Scalars['Boolean']['input']>;\n  values?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;\n};\n\nexport type MergeStakeholdersPreviewType = {\n  __typename?: 'MergeStakeholdersPreviewType';\n  obsoleteShareholderPreview?: Maybe<StakeholderAssetsPreviewType>;\n  prevalentShareholderPreview?: Maybe<StakeholderAssetsPreviewType>;\n};\n\nexport type MessageAnalyticsEntryType = {\n  __typename?: 'MessageAnalyticsEntryType';\n  avatar?: Maybe<Scalars['String']['output']>;\n  displayName?: Maybe<Scalars['String']['output']>;\n  hasLoggedIn?: Maybe<Scalars['Boolean']['output']>;\n  openCount?: Maybe<Scalars['Int']['output']>;\n  reaction?: Maybe<Scalars['String']['output']>;\n};\n\n/** An enumeration. */\nexport enum MessageStatus {\n  Draft = 'DRAFT',\n  Received = 'RECEIVED',\n  Sent = 'SENT'\n}\n\nexport type MfaSetupOutputType = {\n  __typename?: 'MfaSetupOutputType';\n  configUrl?: Maybe<Scalars['String']['output']>;\n  qrcodeImage?: Maybe<Scalars['String']['output']>;\n};\n\nexport type MilestoneVestType = {\n  transactionDate: Scalars['Date']['input'];\n  vestingEventId: Scalars['UUID']['input'];\n};\n\n/**\n *\n *     # This mutation moves the document from the signing process to a folder/category.\n *\n *         mutation Example {\n *             moveFromSigningToDocuments(\n *                 documentId: \"8450926e-7777-9891-4345-d6a2d9694780\",\n *                 folder: \"General\"\n *             ) {\n *               ok\n *             }\n *         }\n *\n */\nexport type MoveFromSigningToDocuments = {\n  __typename?: 'MoveFromSigningToDocuments';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/** Defines write functions available in graphQL endpoint. */\nexport type Mutation = {\n  __typename?: 'Mutation';\n  /**\n   * mutation {\n   *     acceptEquityOffer(\n   *         offer: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  acceptEquityOffer?: Maybe<AcceptEquityOffer>;\n  /**\n   * mutation {\n   *     acceptNotesOffer (\n   *         offer: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  acceptNotesOffer?: Maybe<AcceptNotesOffer>;\n  acceptTermsAndConditions?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   *\n   *     # This mutation adds a buy back to a Sharetype.\n   *\n   *         mutation Example {\n   *         addBuyBack(\n   *             addBuyBackData:\n   *             {\n   *                 amount: 1000.50,\n   *                 shares: 300,\n   *                 shareholder: \"9280926e-8bae-4481-9d2c-d6a2d9694055\",\n   *                 shareType: \"beb6dd77-53b1-4f5a-9e43-da52c1eb8973\",\n   *                 buyBackDate: \"2010-10-24\"\n   *             })\n   *         {\n   *         shareholdingTransaction\n   *         {\n   *             id\n   *         }\n   *         }\n   *         }\n   *\n   */\n  addBuyBack?: Maybe<AddBuyBack>;\n  /**\n   * mutation {\n   *     addEquityRoundOffer(\n   *         round: \"00000000-0000-0000-0000-000000000000\",\n   *         shareholder: \"00000000-0000-0000-0000-000000000000\",\n   *         amount: 10,\n   *         reminderSentDate: \"2010-10-24\"\n   *     )\n   *     { organisationRaiseOffer { id } }\n   * }\n   */\n  addEquityRoundOffer?: Maybe<AddEquityRoundOffer>;\n  addHistorical409A?: Maybe<Scalars['UUID']['output']>;\n  /**\n   *\n   *     # This mutation Adds a new officeholder. Ensure organisationId\n   *     # provided exists and user running the query is an Officeholder.\n   *\n   *     mutation Example {\n   *             addOfficeholder (addOfficeholderData:\n   *             {\n   *             organisationId: \"b280926e-8bae-4481-9d2c-d6a2d969400b\",\n   *             officeholder :\n   *             {\n   *             name: \"John Doe\",\n   *             roles: [{\n   *                 role: \"DIR\",\n   *             }]\n   *             email: \"john.doe@example.com\",\n   *             }\n   *             })\n   *             {\n   *             officeholder\n   *                 {\n   *                 id\n   *                 name\n   *                 roles { role, name}\n   *                 email\n   *                 signer\n   *                 signature\n   *             }\n   *             }\n   *             }\n   *\n   *\n   */\n  addOfficeholder?: Maybe<AddOfficeholder>;\n  addOrRenewSupportRole?: Maybe<Scalars['Boolean']['output']>;\n  addOrUpdateCompanySigners?: Maybe<Scalars['Boolean']['output']>;\n  addShareSplit?: Maybe<ShareholdingTransaction>;\n  addShareholder?: Maybe<Array<Maybe<Shareholder>>>;\n  addShareholderIssueShares?: Maybe<Array<Maybe<Shareholder>>>;\n  addSupportToShareholder?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     addValuation (\n   *         organisation: \"00000000-0000-0000-0000-000000000000\",\n   *         valuationCap: 10.21,\n   *         date: \"1900-01-31\",\n   *         round: \"dfvhufbdhu\"\n   *     ) { valuation { id } }\n   * }\n   */\n  addValuation?: Maybe<ValuationType>;\n  applyHistorical409aStrikePrice?: Maybe<Scalars['Int']['output']>;\n  approveExerciseRequest?: Maybe<Scalars['Boolean']['output']>;\n  assignBareTrustEsop?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  assignBareTrustEss?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  assignBareTrustFounderVesting?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  assignBareTrustRsu?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  assignBareTrustWarrant?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  bulkCreateOffersEsop?: Maybe<Scalars['Boolean']['output']>;\n  bulkCreateOffersEss?: Maybe<Scalars['Boolean']['output']>;\n  bulkCreateOffersRsu?: Maybe<Scalars['Boolean']['output']>;\n  bulkCreateOffersWarrant?: Maybe<Scalars['Boolean']['output']>;\n  bulkDeleteNotes?: Maybe<Scalars['Boolean']['output']>;\n  buyOneOff409A?: Maybe<Scalars['Boolean']['output']>;\n  buyOneOffQsbs?: Maybe<Scalars['Boolean']['output']>;\n  cancelNote?: Maybe<CancelNote>;\n  changeOfferTemplateEsop?: Maybe<Scalars['Boolean']['output']>;\n  changeOfferTemplateEss?: Maybe<Scalars['Boolean']['output']>;\n  changeOfferTemplateRsu?: Maybe<Scalars['Boolean']['output']>;\n  clearGroupOffersEsop?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  clearGroupOffersEss?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  clearGroupOffersFounderVesting?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  clearGroupOffersRsu?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  clearGroupOffersWarrant?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  clearOffersEsop?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  clearOffersEss?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  clearOffersFounderVesting?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  clearOffersRsu?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  clearOffersWarrant?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  clearUserInviteSender?: Maybe<Scalars['Boolean']['output']>;\n  completeOfferEsop?: Maybe<EsopOffer>;\n  completeOfferEss?: Maybe<EssOffer>;\n  completeOfferRsu?: Maybe<RsuOfferOutputType>;\n  completeShareTransferOffer?: Maybe<CompleteShareTransferOffer>;\n  /**\n   * mutation {\n   *     confirmEquityOfferInvestorDetails (\n   *         offer: \"00000000-0000-0000-0000-000000000000\",\n   *         investorData: {}\n   *     ) { ok }\n   * }\n   */\n  confirmEquityOfferInvestorDetails?: Maybe<ConfirmEquityOfferInvestorDetails>;\n  confirmExercisePaymentAndIssueShares?: Maybe<ConfirmExercisePaymentAndIssueShares>;\n  /**\n   * mutation {\n   *     confirmNotesOfferInvestorDetails (\n   *         offer: \"00000000-0000-0000-0000-000000000000\",\n   *         investorData: { investors: [] }\n   *     ) { ok }\n   * }\n   */\n  confirmNotesOfferInvestorDetails?: Maybe<ConfirmNotesOfferInvestorDetails>;\n  confirmOfferInvestorDetailsEsop?: Maybe<Scalars['Boolean']['output']>;\n  confirmOfferInvestorDetailsEss?: Maybe<Scalars['Boolean']['output']>;\n  confirmOfferInvestorDetailsRsu?: Maybe<Scalars['Boolean']['output']>;\n  confirmShareTransferOfferInvestorDetails?: Maybe<ConfirmShareTransferOfferInvestorDetails>;\n  confirmUserInvite?: Maybe<ConfirmUserInvite>;\n  /**\n   * mutation {\n   *     convertNote (\n   *         noteId: \"00000000-0000-0000-0000-000000000000\",\n   *         sharetypeId: \"00000000-0000-0000-0000-000000000000\",\n   *         valuation: 4000,\n   *         pricePerShare: 12.10\n   *     ) {\n   *         sharesIssued\n   *     }\n   * }\n   */\n  convertNote?: Maybe<ConvertNote>;\n  /**\n   * mutation {\n   *     convertNoteManual (\n   *         noteId: \"00000000-0000-0000-0000-000000000000\",\n   *         sharetypeId: \"00000000-0000-0000-0000-000000000000\",\n   *         conversionShares: 4\n   *     ) {\n   *         sharesIssued\n   *     }\n   * }\n   */\n  convertNoteManual?: Maybe<ConvertNoteManual>;\n  convertShares?: Maybe<ConvertShares>;\n  copyMoveFileOrFolder?: Maybe<CopyMoveFileOrFolder>;\n  createBoardApproval?: Maybe<BoardApprovalType>;\n  createCakeGroup?: Maybe<CreateCakeGroup>;\n  createComment?: Maybe<Scalars['Boolean']['output']>;\n  createDemoOrg?: Maybe<CreateDemoOrg>;\n  /**\n   *\n   *     # This mutation creates a draft contract, eg. from a Directors Resolution\n   *     # contract, Shareholders Resolution contract, etc.\n   *\n   *         mutation Example {\n   *             createDraftContract(\n   *                 organisation: \"d280926e-8bae-4481-9d2c-d6a2d9694999\",\n   *                 contractType: \"SHARE_CERTIFICATE\"\n   *             ) {\n   *               ok\n   *             }\n   *         }\n   *\n   */\n  createDraftContract?: Maybe<CreateDraftContract>;\n  createEquityModel?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     createEquityRound(\n   *         organisation: \"00000000-0000-0000-0000-000000000000\",\n   *         name: \"Seed Round\",\n   *         raiseGoalAmount: 1000000,\n   *         valuation: \"00000000-0000-0000-0000-000000000000\",\n   *         existingShares: 300000,\n   *         shareType: \"00000000-0000-0000-0000-000000000000\"\n   *     )\n   *     { organisationRaise { id } }\n   * }\n   */\n  createEquityRound?: Maybe<CreateEquityRound>;\n  createEsop?: Maybe<Esop>;\n  createEss?: Maybe<Ess>;\n  createFolder?: Maybe<CreateFolder>;\n  createGroupEsop?: Maybe<Scalars['Boolean']['output']>;\n  createGroupEss?: Maybe<Scalars['Boolean']['output']>;\n  createGroupRsu?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     createNote (\n   *         shareholderId: \"00000000-0000-0000-0000-000000000000\",\n   *         noteType: \"SAFE\",\n   *         principal: 1000000\n   *     ) { id type principal }\n   * }\n   */\n  createNote?: Maybe<CreateNote>;\n  createNotesOffer?: Maybe<NotesRoundOfferType>;\n  createNotesOfferTemplate?: Maybe<Scalars['Boolean']['output']>;\n  createNotesRaiseAndOfficeholders?: Maybe<CreateNotesRaiseAndOfficeholders>;\n  /**\n   * mutation {\n   *     createNotesRound (\n   *         organisationId: \"00000000-0000-0000-0000-000000000000\",\n   *         name: \"Name\",\n   *         noteType: \"SAFE\",\n   *         roundInvestmentGoal: 1000,\n   *         capitalRaisingEventAmount: 1000,\n   *         endDate: \"2020-05-03\",\n   *         discountRate: 30,\n   *         valuationCap: 1000000,\n   *         interest: 8,\n   *         maturityDate: \"2020-05-03\"\n   *     ) {\n   *         notesRound { id name }\n   *     }\n   * }\n   */\n  createNotesRound?: Maybe<CreateNotesRound>;\n  /**\n   * mutation {\n   *     createNotesRoundOffer (\n   *         round: \"00000000-0000-0000-0000-000000000000\",\n   *         shareholder: \"00000000-0000-0000-0000-000000000000\",\n   *         principal: 10,\n   *     ) { id type principal }\n   * }\n   */\n  createNotesRoundOffer?: Maybe<CreateNotesRoundOffer>;\n  /**\n   * mutation {\n   *     createNotesRoundTemplate (\n   *         round: \"00000000-0000-0000-0000-000000000000\",\n   *         name: \"Cool Convert\"\n   *     ) { ok }\n   * }\n   */\n  createNotesRoundTemplate?: Maybe<CreateNotesRoundTemplate>;\n  createOffboarding?: Maybe<Scalars['Boolean']['output']>;\n  createOfferEsop?: Maybe<Array<Maybe<EsopOffer>>>;\n  createOfferEss?: Maybe<Array<Maybe<EssOffer>>>;\n  createOfferPauseEventEsop?: Maybe<Scalars['Boolean']['output']>;\n  createOfferPauseEventEss?: Maybe<Scalars['Boolean']['output']>;\n  createOfferPauseEventFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  createOfferPauseEventRsu?: Maybe<Scalars['Boolean']['output']>;\n  createOfferPauseEventWarrant?: Maybe<Scalars['Boolean']['output']>;\n  createOfferRsu?: Maybe<Array<Maybe<RsuOfferOutputType>>>;\n  createOfferWarrant?: Maybe<Array<Maybe<WarrantOfferOutputType>>>;\n  /**\n   * mutation createOrganisationSignup {\n   *     createOrganisationSignup(\n   *         name: \"Company Name\",\n   *         country: \"AU\"\n   *     ) { organisation { id } }\n   * }\n   */\n  createOrganisationSignup?: Maybe<CreateOrganisationSignup>;\n  createRsu?: Maybe<RsuOutputType>;\n  createShareTransferOffer?: Maybe<CreateShareTransferOffer>;\n  createShareTransferRound?: Maybe<CreateShareTransferRound>;\n  createShareTransferRoundTemplate?: Maybe<CreateShareTransferRoundTemplate>;\n  /**\n   *\n   *     # This mutation Creates a new Sharetype under an Organisation.\n   *     # Ensure organisationId provided exists.\n   *\n   *     mutation Example {\n   *\n   *      createShareType(createSharetypeData:\n   *      {organisationId: \"bdd66da8-22ce-40e7-8ec1-5d880c25929a\",\n   *      sharetype: {name:\"ORDINARY\", symbol: \"ORD\",\n   *                 voting: false, dividend: false,\n   *                 }})\n   *        {\n   *          sharetype {\n   *            id\n   *            name\n   *            voting\n   *            dividend\n   *            symbol\n   *            totals {\n   *             amountRaised\n   *             totalShares\n   *             totalDue\n   *            }\n   *          }\n   *        }\n   *        }\n   *\n   */\n  createShareType?: Maybe<CreateShareType>;\n  createTemplateEsop?: Maybe<Scalars['Boolean']['output']>;\n  createTemplateEss?: Maybe<Scalars['Boolean']['output']>;\n  createTemplateNote?: Maybe<Scalars['Boolean']['output']>;\n  createTemplateRsu?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     createVestingScheduleTemplate(\n   *         organisation: \"78c70bb5-934f-4be5-aa7a-8df308c26cc7\",\n   *         name: \"Le template\",\n   *         vestingScheduleTemplate: {\n   *             events: [\n   *                 {\n   *                     vestingValuePercentage: 25.0,\n   *                     vestingData: { duration: { value: 1, granularity: \"MONTHS\" } }\n   *                 },\n   *                 {\n   *                     vestingValuePercentage: 75.0,\n   *                     vestingData: { frequency: { value: 1, granularity: \"MONTHS\" },\n   *                     duration: { value: 1, granularity: \"YEARS\" } }\n   *                 }\n   *             ]\n   *         }\n   *     )\n   * }\n   */\n  createVestingScheduleTemplate?: Maybe<Scalars['Boolean']['output']>;\n  debugRefreshExchangeRates?: Maybe<Scalars['Boolean']['output']>;\n  debugRefreshLicense?: Maybe<LicenseInfoType>;\n  debugReportUsage?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     declineEquityOffer(\n   *         offer: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  declineEquityOffer?: Maybe<DeclineEquityOffer>;\n  /**\n   * mutation {\n   *     declineNotesOffer (\n   *         offer: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  declineNotesOffer?: Maybe<DeclineNotesOffer>;\n  declineOfferEsop?: Maybe<Scalars['Boolean']['output']>;\n  declineOfferEss?: Maybe<Scalars['Boolean']['output']>;\n  declineOfferRsu?: Maybe<Scalars['Boolean']['output']>;\n  declineShareTransferOffer?: Maybe<DeclineShareTransferOffer>;\n  deleteAllSupportRoles?: Maybe<Scalars['Boolean']['output']>;\n  deleteBoardApproval?: Maybe<Scalars['Boolean']['output']>;\n  deleteCakeGroup?: Maybe<DeleteCakeGroup>;\n  deleteComment?: Maybe<Scalars['Int']['output']>;\n  /**\n   *\n   *     # This mutation deletes a document\n   *\n   *     mutation Example {\n   *       deleteDocument(\n   *           documents: [\"34543505-7c7f-4127-bef8-a4d1bc3ce007\"]\n   *       ) {\n   *             ok\n   *         }\n   *     }\n   *\n   */\n  deleteDocument?: Maybe<DeleteDocument>;\n  deleteEquityModel?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     deleteEquityRound(\n   *         round: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  deleteEquityRound?: Maybe<DeleteEquityRound>;\n  /**\n   * mutation {\n   *     deleteEquityRoundOffer(\n   *         offer: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  deleteEquityRoundOffer?: Maybe<DeleteEquityRoundOffer>;\n  deleteEsop?: Maybe<Scalars['Boolean']['output']>;\n  deleteEss?: Maybe<Scalars['Boolean']['output']>;\n  deleteGroupEsop?: Maybe<Scalars['Boolean']['output']>;\n  deleteGroupEss?: Maybe<Scalars['Boolean']['output']>;\n  deleteGroupRsu?: Maybe<Scalars['Boolean']['output']>;\n  deleteHistorical409A?: Maybe<Scalars['Boolean']['output']>;\n  deleteMessage?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     deleteNote (\n   *         note: \"00000000-0000-0000-0000-000000000000\"\n   *     )\n   * }\n   */\n  deleteNote?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     deleteNotesRound (\n   *         round: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  deleteNotesRound?: Maybe<DeleteNotesRound>;\n  deleteNotesRoundOffer?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     deleteNotesRoundTemplate (\n   *         round: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  deleteNotesRoundTemplate?: Maybe<DeleteNotesRoundTemplate>;\n  deleteOffboarding?: Maybe<Scalars['Boolean']['output']>;\n  deleteOfferPauseEventEsop?: Maybe<Scalars['Boolean']['output']>;\n  deleteOfferPauseEventEss?: Maybe<Scalars['Boolean']['output']>;\n  deleteOfferPauseEventFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  deleteOfferPauseEventRsu?: Maybe<Scalars['Boolean']['output']>;\n  deleteOfferPauseEventWarrant?: Maybe<Scalars['Boolean']['output']>;\n  deleteOffersEsop?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  deleteOffersEss?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  deleteOffersFounderVesting?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  deleteOffersRsu?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  deleteOffersWarrant?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /**\n   *\n   *     # This mutation deletes an officeholder. Ensure officeholderId\n   *     # provided exists and user running the query is an Officeholder.\n   *\n   *     mutation Example {\n   *         deleteOfficeholder (officeholder: \"f3a5cddd-a8f0-45a1-b696-073616228bc6\")\n   *         { organisation  { id } }\n   *     }\n   *\n   *\n   */\n  deleteOfficeholder?: Maybe<DeleteOfficeholder>;\n  deleteRsu?: Maybe<Scalars['Boolean']['output']>;\n  deleteScanbotDocument?: Maybe<Scalars['Boolean']['output']>;\n  deleteShareCertificateDisclaimer?: Maybe<Scalars['Boolean']['output']>;\n  deleteShareTransferOffer?: Maybe<DeleteShareTransferOffer>;\n  deleteShareTransferRound?: Maybe<DeleteShareTransferRound>;\n  deleteShareTransferRoundTemplate?: Maybe<DeleteShareTransferRoundTemplate>;\n  deleteShareholders?: Maybe<ShareholdersDeleteAttempt>;\n  /**\n   *\n   *     # This mutation deletes a sharetype. Ensure sharetypeId\n   *     # provided exists and user running the query is an Officeholder.\n   *\n   *     mutation Example {\n   *             deleteSharetype (\n   *                 sharetype: \"f3a5cddd-a8f0-45a1-b696-073616228bc6\"\n   *             ) { ok }\n   *         }\n   *\n   *\n   */\n  deleteSharetype?: Maybe<DeleteSharetype>;\n  deleteSupportRoles?: Maybe<Scalars['Boolean']['output']>;\n  deleteSupportToShareholder?: Maybe<Scalars['Boolean']['output']>;\n  deleteTransactions?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     deleteValuation (\n   *         valuation: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  deleteValuation?: Maybe<DeleteValuation>;\n  deleteVestingScheduleTemplate?: Maybe<Scalars['Boolean']['output']>;\n  editEquityModel?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *         editEquityRound (\n   *             round: \"00000000-0000-0000-0000-000000000000\"\n   *         ) { ok }\n   * }\n   */\n  editEquityRound?: Maybe<EditEquityRound>;\n  editEsop?: Maybe<Scalars['Boolean']['output']>;\n  editEss?: Maybe<Scalars['Boolean']['output']>;\n  editExerciseRequestSettings?: Maybe<Scalars['Boolean']['output']>;\n  editGroupEsop?: Maybe<Scalars['Boolean']['output']>;\n  editGroupEss?: Maybe<Scalars['Boolean']['output']>;\n  editGroupRsu?: Maybe<Scalars['Boolean']['output']>;\n  editGroupWarrant?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     editNote (\n   *         note: \"00000000-0000-0000-0000-000000000000\",\n   *         principal: 2000000\n   *     ) { id principal }\n   * }\n   */\n  editNote?: Maybe<Scalars['Boolean']['output']>;\n  editNotesOffer?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *         editNotesRound (\n   *             round: \"00000000-0000-0000-0000-000000000000\"\n   *         ) { ok }\n   * }\n   */\n  editNotesRound?: Maybe<EditNotesRound>;\n  editOffboarding?: Maybe<Scalars['Boolean']['output']>;\n  editOfferPauseEventEsop?: Maybe<Scalars['Boolean']['output']>;\n  editOfferPauseEventEss?: Maybe<Scalars['Boolean']['output']>;\n  editOfferPauseEventFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  editOfferPauseEventRsu?: Maybe<Scalars['Boolean']['output']>;\n  editOfferPauseEventWarrant?: Maybe<Scalars['Boolean']['output']>;\n  editOnboardedShareholders?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantExercisePriceEsop?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantExercisePriceEss?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantExercisePriceFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantExercisePriceRsu?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantExercisePriceWarrant?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantExpirationEsop?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantGrantDateEsop?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantGrantDateEss?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantGrantDateFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantGrantDateRsu?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantGrantDateWarrant?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantOptionPriceEsop?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantPtepEsop?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantPtepEss?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantPtepFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantPtepRsu?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantPtepWarrant?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantVestStartDateEsop?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantVestStartDateEss?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantVestStartDateFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantVestStartDateRsu?: Maybe<Scalars['Boolean']['output']>;\n  editPostGrantVestStartDateWarrant?: Maybe<Scalars['Boolean']['output']>;\n  editRsu?: Maybe<Scalars['Boolean']['output']>;\n  editShareTransferOffer?: Maybe<EditShareTransferOffer>;\n  editShareTransferRound?: Maybe<EditShareTransferRound>;\n  editTransaction?: Maybe<Scalars['Boolean']['output']>;\n  editVestingScheduleTemplate?: Maybe<Scalars['Boolean']['output']>;\n  enableDisableAutoVestEsop?: Maybe<Scalars['Boolean']['output']>;\n  enableDisableAutoVestEss?: Maybe<Scalars['Boolean']['output']>;\n  enableDisableAutoVestFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  enableDisableAutoVestRsu?: Maybe<Scalars['Boolean']['output']>;\n  enableDisableAutoVestWarrant?: Maybe<Scalars['Boolean']['output']>;\n  exerciseOptionsEsop?: Maybe<ExerciseOptionsEsop>;\n  exerciseWarrants?: Maybe<ExerciseWarrants>;\n  /**\n   *\n   *     # This mutation sets document ready.\n   *\n   *         mutation Example {\n   *             finaliseTemplate(\n   *                 document: \"8450926e-7777-9891-4345-d6a2d9694780\"\n   *             ) {\n   *               ok\n   *             }\n   *         }\n   *\n   */\n  finaliseTemplate?: Maybe<FinaliseTemplate>;\n  fixContractTemplatePlaceholders?: Maybe<Scalars['Boolean']['output']>;\n  forceUpdateSigningStatus?: Maybe<Scalars['Boolean']['output']>;\n  fullyLapseOfferEsop?: Maybe<Scalars['Boolean']['output']>;\n  fullyLapseOfferEss?: Maybe<Scalars['Boolean']['output']>;\n  fullyLapseOfferFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  fullyLapseOfferRsu?: Maybe<Scalars['Boolean']['output']>;\n  fullyLapseOfferWarrant?: Maybe<Scalars['Boolean']['output']>;\n  generateQsbsReportForTransactions?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation generateShareCertificateByCriteria (\n   *     $organisationId: OrganisationCakeType!,\n   *     $certificateNumber: Int!,\n   *     $filterDate: Date,\n   *     $filterDateIsGte: Boolean,\n   *     $filterShareType: SharetypeCakeType,\n   *     $issueDate: Date,\n   * ) {\n   *     generateShareCertificateByCriteria (\n   *         organisation: $organisationId,\n   *         certificateNumber: $certificateNumber,\n   *         filterDate: $filterDate,\n   *         filterDateIsGte: $filterDateIsGte,\n   *         filterShareType: $filterShareType,\n   *         certificateIssueDate: $issueDate,\n   *     )\n   * }\n   */\n  generateShareCertificateByCriteria?: Maybe<Scalars['Int']['output']>;\n  /**\n   * mutation generateShareCertificatesFromHoldings(\n   *     $shareholderIds: [ShareholderCakeType]!,\n   *     $certificateNumber: Int!,\n   *     $selectionOrganisationId: OrganisationCakeType,\n   *     $selectionSearch: String,\n   *     $notifyShareholder: Boolean,\n   *     $disclaimersBySharetype: [SharetypeDisclaimerInputType!]\n   * ) {\n   *     generateShareCertificatesFromHoldings (\n   *         shareholders: $shareholderIds,\n   *         certificateNumber: $certificateNumber,\n   *         organisation: $selectionOrganisationId,\n   *         selectionSearch: $selectionSearch,\n   *         notifyShareholder: $notifyShareholder,\n   *         disclaimersBySharetype: $disclaimersBySharetype\n   *     ) {\n   *         lastCertificateNumber\n   *     }\n   * }\n   */\n  generateShareCertificatesFromHoldings?: Maybe<GenerateShareCertificates>;\n  /**\n   * mutation generateTransactionalShareCertificate (\n   *     $transactionId: ShareholdingTransactionCakeType!,\n   *     $certificateNumber: PositiveInteger!,\n   *     $issueDate: Date,\n   *     $disclaimerBySharetype: SharetypeDisclaimerInputType\n   * ) {\n   *     generateTransactionalShareCertificate (\n   *         transaction: $transactionId,\n   *         certificateNumber: $certificateNumber,\n   *         issueDate: $issueDate,\n   *         disclaimerBySharetype: $disclaimerBySharetype\n   *     )\n   * }\n   */\n  generateTransactionalShareCertificate?: Maybe<Scalars['Int']['output']>;\n  generateUsIrsForm3921?: Maybe<Scalars['Boolean']['output']>;\n  grantOfferEsop?: Maybe<Scalars['Boolean']['output']>;\n  grantOfferEss?: Maybe<Scalars['Boolean']['output']>;\n  grantOfferFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  grantOfferRsu?: Maybe<Scalars['Boolean']['output']>;\n  grantOfferWarrant?: Maybe<Scalars['Boolean']['output']>;\n  grantOffersEsop?: Maybe<Scalars['Boolean']['output']>;\n  grantOffersEss?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  grantOffersRsu?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  grantOffersWarrant?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  inviteAllOffersEsop?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /**\n   * mutation {\n   *   inviteEquityOffer(\n   *       offer: \"00000000-0000-0000-0000-000000000000\"\n   *   ) { ok }\n   * }\n   */\n  inviteEquityOffer?: Maybe<InviteEquityOffer>;\n  inviteJoinCake?: Maybe<InviteJoinCake>;\n  /**\n   * mutation {\n   *     inviteNotesOffer (\n   *         offer: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  inviteNotesOffer?: Maybe<InviteNotesOffer>;\n  inviteOfferEsop?: Maybe<Scalars['Boolean']['output']>;\n  inviteOfferEss?: Maybe<Scalars['Boolean']['output']>;\n  inviteOfferRsu?: Maybe<Scalars['Boolean']['output']>;\n  inviteOffersEsop?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  inviteOffersEss?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  inviteOffersRsu?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  inviteShareTransferOffer?: Maybe<InviteShareTransferOffer>;\n  inviteUsers?: Maybe<InviteUsers>;\n  /**\n   * mutation {\n   *     issueOfferNote (\n   *         offer: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { note { id } }\n   * }\n   */\n  issueOfferNote?: Maybe<IssueOfferNote>;\n  /**\n   * mutation {\n   *     issueOfferShares(\n   *         offer: \"00000000-0000-0000-0000-000000000000\",\n   *         certificateCount: 17\n   *     ) { certificate {{ id }} shareholdingTransaction {{ shares }}  }\n   * }\n   */\n  issueOfferShares?: Maybe<IssueOfferShares>;\n  issueShares?: Maybe<Scalars['Boolean']['output']>;\n  issueSharesFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  issueSharesWarrant?: Maybe<Scalars['Boolean']['output']>;\n  lapseMilestoneEsop?: Maybe<Scalars['Boolean']['output']>;\n  lapseMilestoneEss?: Maybe<Scalars['Boolean']['output']>;\n  lapseMilestoneFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  lapseMilestoneRsu?: Maybe<Scalars['Boolean']['output']>;\n  lapseMilestoneWarrant?: Maybe<Scalars['Boolean']['output']>;\n  lapseOfferEsop?: Maybe<Scalars['Boolean']['output']>;\n  lapseOfferEss?: Maybe<Scalars['Boolean']['output']>;\n  lapseOfferFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  lapseOfferRsu?: Maybe<Scalars['Boolean']['output']>;\n  lapseOfferWarrant?: Maybe<Scalars['Boolean']['output']>;\n  mergeStakeholders?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   *\n   *     # This mutation moves the document from the signing process to a folder/category.\n   *\n   *         mutation Example {\n   *             moveFromSigningToDocuments(\n   *                 documentId: \"8450926e-7777-9891-4345-d6a2d9694780\",\n   *                 folder: \"General\"\n   *             ) {\n   *               ok\n   *             }\n   *         }\n   *\n   */\n  moveFromSigningToDocuments?: Maybe<MoveFromSigningToDocuments>;\n  moveOffersEsop?: Maybe<Scalars['Boolean']['output']>;\n  moveOffersEss?: Maybe<Scalars['Boolean']['output']>;\n  moveOffersRsu?: Maybe<Scalars['Boolean']['output']>;\n  onOffAutoVestEmailsAllEsop?: Maybe<Scalars['Boolean']['output']>;\n  onOffAutoVestEmailsAllEss?: Maybe<Scalars['Boolean']['output']>;\n  onOffAutoVestEmailsAllFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  onOffAutoVestEmailsAllRsu?: Maybe<Scalars['Boolean']['output']>;\n  onOffAutoVestEmailsAllWarrant?: Maybe<Scalars['Boolean']['output']>;\n  onOffAutoVestEmailsEsop?: Maybe<Scalars['Boolean']['output']>;\n  onOffAutoVestEmailsEss?: Maybe<Scalars['Boolean']['output']>;\n  onOffAutoVestEmailsFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  onOffAutoVestEmailsRsu?: Maybe<Scalars['Boolean']['output']>;\n  onOffAutoVestEmailsWarrant?: Maybe<Scalars['Boolean']['output']>;\n  onboardingShown?: Maybe<Scalars['Boolean']['output']>;\n  overrideDelinquentLock?: Maybe<Scalars['Boolean']['output']>;\n  pauseSubscription?: Maybe<Scalars['Boolean']['output']>;\n  payPendingInvoices?: Maybe<StripeInvoicePaymentAttemptResult>;\n  refreshScanbotStatus?: Maybe<Scalars['Boolean']['output']>;\n  rejectExerciseRequest?: Maybe<Scalars['Boolean']['output']>;\n  remindAllOffers?: Maybe<Array<Maybe<Scalars['UUID']['output']>>>;\n  /**\n   * mutation {\n   *     removeOrganisationUserRoles(\n   *         user: \"00000000-0000-0000-0000-000000000000\",\n   *         organisation: \"00000000-0000-0000-0000-000000000000\"\n   *     )\n   * }\n   */\n  removeOrganisationUserRoles?: Maybe<Array<Maybe<Scalars['CleanString']['output']>>>;\n  removeShareDocument?: Maybe<RemoveShareDocument>;\n  /**\n   *\n   *     # This mutation deletes a document\n   *\n   *     mutation Example {\n   *       renameDocument(\n   *           documentId: \"34543505-7c7f-4127-bef8-a4d1bc3ce007\",\n   *           newName: \"Document name number two\"\n   *       ) {\n   *             ok\n   *         }\n   *     }\n   *\n   */\n  renameDocument?: Maybe<RenameDocument>;\n  /**\n   * mutation {\n   *     repayNote (\n   *         noteId: \"00000000-0000-0000-0000-000000000000\",\n   *     ) {\n   *         ok\n   *     }\n   * }\n   */\n  repayNote?: Maybe<RepayNote>;\n  requestCancelSubscription: Scalars['String']['output'];\n  requestEmailChange?: Maybe<Scalars['Boolean']['output']>;\n  requestExercise?: Maybe<Scalars['Boolean']['output']>;\n  resetNotesOffer?: Maybe<Scalars['Boolean']['output']>;\n  resetOffersEsop?: Maybe<Scalars['Boolean']['output']>;\n  resetOffersEss?: Maybe<Scalars['Boolean']['output']>;\n  resetOffersFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  resetOffersRsu?: Maybe<Scalars['Boolean']['output']>;\n  resetOffersWarrant?: Maybe<Scalars['Boolean']['output']>;\n  resetUserMfaEnroll?: Maybe<Scalars['Boolean']['output']>;\n  revertCancelSubscription?: Maybe<Scalars['Boolean']['output']>;\n  revokeUserInvitation?: Maybe<Scalars['Boolean']['output']>;\n  saveMessage?: Maybe<Scalars['UUID']['output']>;\n  saveShareCertificateDisclaimer?: Maybe<Scalars['UUID']['output']>;\n  send409aProviderNotification?: Maybe<Scalars['Boolean']['output']>;\n  sendActivityLogFeedback?: Maybe<Scalars['Boolean']['output']>;\n  sendAsc718Request?: Maybe<Scalars['Boolean']['output']>;\n  sendBoardApprovalReminder?: Maybe<Scalars['Boolean']['output']>;\n  sendCakeTestKitchenEmail?: Maybe<Scalars['Boolean']['output']>;\n  sendCaptableDocumentUploadEmails?: Maybe<Scalars['Boolean']['output']>;\n  sendChurnDiscountRequest?: Maybe<Scalars['Boolean']['output']>;\n  sendContractForSigningEsop?: Maybe<Scalars['Boolean']['output']>;\n  sendEmployeeLicenseBlockEmail?: Maybe<Scalars['Boolean']['output']>;\n  sendEsopDocumentUploadEmails?: Maybe<Scalars['Boolean']['output']>;\n  sendKudos?: Maybe<Scalars['Boolean']['output']>;\n  sendMessage?: Maybe<SendMessageOutputType>;\n  sendRequest409aCallback?: Maybe<Scalars['Boolean']['output']>;\n  sendTestTransactionalEmail?: Maybe<SendTestTransactionalEmail>;\n  setLoanFundedAllEss?: Maybe<Scalars['Boolean']['output']>;\n  setLoanFundedAllFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  setLoanFundedEss?: Maybe<Scalars['Boolean']['output']>;\n  setLoanFundedFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  setNotesOfferTemplate?: Maybe<Scalars['Boolean']['output']>;\n  setNotesRoundTemplate?: Maybe<Scalars['Boolean']['output']>;\n  setUserEmployeeGoal?: Maybe<Scalars['Boolean']['output']>;\n  setUserPreference?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * # Skip the invite flow for offers tracked off-platform or adding historical data.\n   * mutation {\n   *     settleEquityOfferOffline (\n   *         offer: \"00000000-0000-0000-0000-000000000000\",\n   *         contract: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  settleEquityOfferOffline?: Maybe<SettleEquityOfferOffline>;\n  settleExerciseRequestOffline?: Maybe<SettleExerciseRequestOffline>;\n  /**\n   * # Skip the invite flow for offers tracked off-platform or adding historical data.\n   * mutation {\n   *     settleNotesOfferOffline (\n   *         offer: \"00000000-0000-0000-0000-000000000000\",\n   *         principal: 10,\n   *         contract: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  settleNotesOfferOffline?: Maybe<SettleNotesOfferOffline>;\n  settleShareTransferOfferOffline?: Maybe<SettleShareTransferOfferOffline>;\n  setupExerciseRequestSettings?: Maybe<Scalars['UUID']['output']>;\n  setupSharetypes?: Maybe<Array<Maybe<Sharetype>>>;\n  shareDocument?: Maybe<ShareDocument>;\n  /**\n   *\n   *     # This mutation lets an investor sign a note agreement.\n   *\n   *         mutation Example {\n   *             signNoteAgreement(\n   *                 offerId: \"b280926e-8bae-4481-9d2c-d6a2d9694768\",\n   *                 secondSignatureName: \"Bo Kranknap\",\n   *                 secondSignatureEmail: \"bo.kr@hottimail.com\"\n   *             )\n   *             {\n   *                 urlList, signatureRequestId\n   *             }\n   *         }\n   *\n   */\n  signNoteAgreement?: Maybe<SignNoteAgreement>;\n  /**\n   * # This mutation signs a document.\n   *\n   * mutation Example {\n   *     signNoteAgreementOfficeholder (\n   *         offerId: \"f3a522dd-a8f0-45a1-4444-0736162233c6\"\n   *     )\n   *     {\n   *         urlList, signatureRequestId\n   *     }\n   * }\n   */\n  signNoteAgreementOfficeholder?: Maybe<SignNoteAgreementOfficeholder>;\n  signOfferLetterEsop?: Maybe<SignOfferLetterEsop>;\n  signOfferLetterEss?: Maybe<SignOfferLetterEss>;\n  signOfferLetterRsu?: Maybe<SignOfferLetterRsu>;\n  /**\n   *\n   *     # This mutation lets an investor sign a note agreement.\n   *\n   *         mutation Example {\n   *             signNoteAgreement(\n   *                 offerId: \"b280926e-8bae-4481-9d2c-d6a2d9694768\",\n   *                 secondSignatureName: \"Bo Kranknap\",\n   *                 secondSignatureEmail: \"bo.kr@hottimail.com\"\n   *             )\n   *             {\n   *                 urlList, signatureRequestId\n   *             }\n   *         }\n   *\n   */\n  signShareTransferAgreement?: Maybe<SignShareTransferAgreement>;\n  /**\n   *\n   *     # This mutation lets an investor sign a subscription agreement.\n   *\n   *         mutation Example {\n   *             signSubscriptionAgreement(\n   *                 offerId: \"b280926e-8bae-4481-9d2c-d6a2d9694768\",\n   *                 witness: {\n   *                     secondSignatureName: \"Bo Kranknap\",\n   *                     secondSignatureEmail: \"bo.kr@hottimail.com\"\n   *                 }\n   *             )\n   *             {\n   *                 urlList, signatureRequestId\n   *             }\n   *         }\n   *\n   */\n  signSubscriptionAgreement?: Maybe<SignSubscriptionAgreement>;\n  /**\n   *\n   *     # This mutation signs a document.\n   *\n   *     mutation Example {\n   *         signSubscriptionAgreementOfficeholder (\n   *             raiseOfferId: \"f3a522dd-a8f0-45a1-4444-0736162233c6\"\n   *         )\n   *         {\n   *             urlList, signatureRequestId\n   *         }\n   *     }\n   *\n   */\n  signSubscriptionAgreementOfficeholder?: Maybe<SignSubscriptionAgreementOfficeholder>;\n  skipUserOnboarding?: Maybe<Scalars['Boolean']['output']>;\n  startContractSigning?: Maybe<StartContractSigning>;\n  submitExercisePayment?: Maybe<Scalars['Boolean']['output']>;\n  supportDeleteOrganisation?: Maybe<Scalars['Boolean']['output']>;\n  syncWithMasterTemplate?: Maybe<Scalars['Boolean']['output']>;\n  toggleAllowEarlyExerciseAllEsop?: Maybe<Scalars['Boolean']['output']>;\n  toggleAllowEarlyExerciseEsop?: Maybe<Scalars['Boolean']['output']>;\n  toggleAssignConversionLockRsu?: Maybe<Scalars['Int']['output']>;\n  toggleCompleteConversionLockRsu?: Maybe<Scalars['Int']['output']>;\n  toggleDisclosurePeriodEsop?: Maybe<Scalars['Boolean']['output']>;\n  toggleDisclosurePeriodEss?: Maybe<Scalars['Boolean']['output']>;\n  toggleDisclosurePeriodFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  toggleDisclosurePeriodRsu?: Maybe<Scalars['Boolean']['output']>;\n  toggleDisclosurePeriodWarrant?: Maybe<Scalars['Boolean']['output']>;\n  toggleMessageAllowReplies?: Maybe<Scalars['Boolean']['output']>;\n  toggleMfaRequired?: Maybe<ToggleMfaRequired>;\n  toggleOrganisationAllowReplies?: Maybe<Scalars['Boolean']['output']>;\n  toggleWitnessOfferLetterAllEsop?: Maybe<Scalars['Boolean']['output']>;\n  toggleWitnessOfferLetterAllEss?: Maybe<Scalars['Boolean']['output']>;\n  toggleWitnessOfferLetterAllRsu?: Maybe<Scalars['Boolean']['output']>;\n  toggleWitnessOfferLetterEsop?: Maybe<Scalars['Boolean']['output']>;\n  toggleWitnessOfferLetterEss?: Maybe<Scalars['Boolean']['output']>;\n  toggleWitnessOfferLetterRsu?: Maybe<Scalars['Boolean']['output']>;\n  toggleWitnessOfferNote?: Maybe<Scalars['Boolean']['output']>;\n  toggleWitnessSubscriptionAgreement?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     touchOffers (\n   *         offerIds: [\"00000000-0000-0000-0000-000000000000\"],\n   *         remind: false\n   *     ) { successfullTouches }\n   * }\n   */\n  touchOffers?: Maybe<Array<Maybe<Scalars['UUID']['output']>>>;\n  /**\n   *\n   *     # This mutation transfers Shares from a shareholder to another.\n   *     # Ensure sharetype between shareholders is same.\n   *     # Ensure shareholder id's exist and user running query is an Officeholder.\n   *\n   *     mutation Example {\n   *             transferShares (transferSharesData: {\n   *                 fromShareholder: \"f3a5cddd-a8f0-45a1-b696-073616228bc8\"\n   *                 toShareholder: \"7a8ee595-76e2-4a1a-bf64-7904c9180457\"\n   *                 shareType: \"beb6dd77-53b1-4f5a-9e43-da52c1eb8973\"\n   *                 quantity: 100\n   *                 amount : 2350.50\n   *                 transferDate: \"2019-01-25\"\n   *             }) { organisation { id } }\n   *     }\n   *\n   */\n  transferShares?: Maybe<TransferShares>;\n  update83bFormDownloadStatus?: Maybe<Scalars['Boolean']['output']>;\n  updateBillingContact?: Maybe<Scalars['Boolean']['output']>;\n  updateCakeGroup?: Maybe<UpdateCakeGroup>;\n  /**\n   *\n   *     # This mutation updates the email subject and body in the document.\n   *\n   *         mutation Example {\n   *             updateContractEmail(\n   *                 documentId: \"8450926e-7777-9891-4345-d6a2d9694780\",\n   *                 subject: \"Directors Resolution invitation to sign\",\n   *                 body: \"Welcome to the team\"\n   *             ) {\n   *               ok\n   *             }\n   *         }\n   *\n   */\n  updateContractEmail?: Maybe<UpdateContractEmail>;\n  updateCreditCard?: Maybe<StripeInvoicePaymentAttemptResult>;\n  /**\n   * mutation {\n   *     updateEquityOfferPaymentStatus (\n   *         offer: \"00000000-0000-0000-0000-000000000000\",\n   *         paid: 350\n   *     ) { ok }\n   * }\n   */\n  updateEquityOfferPaymentStatus?: Maybe<UpdateEquityOfferPaymentStatus>;\n  /**\n   * mutation {\n   *     updateEquityRoundBankDetailsAu (\n   *         round: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  updateEquityRoundBankDetailsAu?: Maybe<UpdateEquityRoundBankDetailsAu>;\n  /**\n   * mutation {\n   *     updateEquityRoundBankDetailsFallback (\n   *         round: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  updateEquityRoundBankDetailsFallback?: Maybe<UpdateEquityRoundBankDetailsFallback>;\n  /**\n   * mutation {\n   *     updateEquityRoundBankDetailsSg (\n   *         round: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  updateEquityRoundBankDetailsSg?: Maybe<UpdateEquityRoundBankDetailsSg>;\n  updateGroupDefaultTemplateEsop?: Maybe<Scalars['Boolean']['output']>;\n  updateGroupDefaultTemplateEss?: Maybe<Scalars['Boolean']['output']>;\n  updateGroupDefaultTemplateRsu?: Maybe<Scalars['Boolean']['output']>;\n  updateHubspotMobileNumber?: Maybe<Scalars['Boolean']['output']>;\n  updateMessageAnalytics?: Maybe<Scalars['Boolean']['output']>;\n  updateMessageReaction?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   * mutation {\n   *     updateNotesOfferPaymentStatus (\n   *         offer: \"00000000-0000-0000-0000-000000000000\",\n   *         paid: 350\n   *     ) { ok }\n   * }\n   */\n  updateNotesOfferPaymentStatus?: Maybe<UpdateNotesOfferPaymentStatus>;\n  /**\n   * mutation {\n   *     updateNotesRoundBankDetailsAu (\n   *         round: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  updateNotesRoundBankDetailsAu?: Maybe<UpdateNotesRoundBankDetailsAu>;\n  /**\n   * mutation {\n   *     UpdateNotesRoundBankDetailsFallback (\n   *         round: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  updateNotesRoundBankDetailsFallback?: Maybe<UpdateNotesRoundBankDetailsFallback>;\n  /**\n   * mutation {\n   *     updateNotesRoundBankDetailsSg (\n   *         round: \"00000000-0000-0000-0000-000000000000\"\n   *     ) { ok }\n   * }\n   */\n  updateNotesRoundBankDetailsSg?: Maybe<UpdateNotesRoundBankDetailsSg>;\n  updateOfferEsop?: Maybe<Scalars['Boolean']['output']>;\n  updateOfferEss?: Maybe<Scalars['Boolean']['output']>;\n  updateOfferRsu?: Maybe<Scalars['Boolean']['output']>;\n  updateOfferSharePriceEss?: Maybe<Scalars['Boolean']['output']>;\n  updateOfferSharePriceFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  updateOfferWarrant?: Maybe<Scalars['Boolean']['output']>;\n  /**\n   *\n   *     # This mutation Updates an existing officeholder. Ensure officeholder\n   *     # id provided exists and user running the query is an Officeholder.\n   *\n   *     mutation Example {\n   *         updateOfficeholder(\n   *             updateOfficeholderData:{\n   *                 officeholder:{\n   *                     id:\"f3a5cddd-a8f0-45a1-b696-073616228bc6\",\n   *                     name:\"Egon Jensen\",\n   *                     email:\"hello@example.com\",\n   *                     roles: [{\n   *                         role: \"DIR\",\n   *                     }]\n   *                 }\n   *             }\n   *         ) {\n   *             officeholder {\n   *                 id\n   *                 name\n   *                 email\n   *                 roles { role, name }\n   *                 signer\n   *                 signature\n   *             }\n   *         }\n   *     }\n   *\n   */\n  updateOfficeholder?: Maybe<UpdateOfficeholder>;\n  updateOneTimeAddonStatus?: Maybe<Scalars['Boolean']['output']>;\n  updateOrganisationAu?: Maybe<UpdateOrganisationAu>;\n  updateOrganisationBasic?: Maybe<UpdateOrganisationBasic>;\n  updateOrganisationCa?: Maybe<UpdateOrganisationCa>;\n  updateOrganisationEe?: Maybe<UpdateOrganisationEe>;\n  updateOrganisationFundingPhase?: Maybe<Scalars['Boolean']['output']>;\n  updateOrganisationGb?: Maybe<UpdateOrganisationGb>;\n  updateOrganisationHideUpcomingInvoice?: Maybe<Scalars['Boolean']['output']>;\n  updateOrganisationIn?: Maybe<UpdateOrganisationIn>;\n  updateOrganisationNz?: Maybe<UpdateOrganisationNz>;\n  updateOrganisationSg?: Maybe<UpdateOrganisationSg>;\n  updateOrganisationUploadInProgress?: Maybe<Scalars['Boolean']['output']>;\n  updateOrganisationUs?: Maybe<UpdateOrganisationUs>;\n  /**\n   * mutation {\n   *     updateOrganisationUserRole(\n   *         user: \"00000000-0000-0000-0000-000000000000\",\n   *         organisation: \"00000000-0000-0000-0000-000000000000\",\n   *         role: \"VIEW\",\n   *         position: \"ATTORNEY\"\n   *     )\n   * }\n   */\n  updateOrganisationUserRole?: Maybe<Scalars['CleanString']['output']>;\n  updateShareTransferOfferPaymentStatus?: Maybe<UpdateShareTransferOfferPaymentStatus>;\n  updateShareholder?: Maybe<Shareholder>;\n  /**\n   *\n   *     # This mutation Updates an existing sharetype. Ensure sharetype\n   *     # id provided exists and user running the query is an Officeholder.\n   *\n   *     mutation Example {\n   *         updateSharetype(\n   *             updateSharetypeData:{\n   *                 sharetype:{\n   *                     id:\"f3a5cddd-a8f0-45a1-b696-073616228bc6\",\n   *                     name:\"Ordinary\",\n   *                     symbol:\"ORD\",\n   *                     voting:false,\n   *                     dividend:false,\n   *                 }\n   *             }\n   *         ) {\n   *             sharetype {\n   *                 id\n   *                 name\n   *                 symbol\n   *                 voting\n   *                 dividend\n   *                 totals {\n   *                     amountRaised\n   *                     totalShares\n   *                     totalDue\n   *                 }\n   *                 }\n   *             }\n   *         }\n   *\n   */\n  updateSharetype?: Maybe<UpdateSharetype>;\n  updateSigner?: Maybe<UpdateSigner>;\n  updateTransactionUnpaidAmount?: Maybe<UpdateTransactionUnpaidAmount>;\n  updateUserOnboarding?: Maybe<Scalars['Boolean']['output']>;\n  updateUserSettings?: Maybe<Scalars['Boolean']['output']>;\n  updateVisibilitySettings?: Maybe<Scalars['Boolean']['output']>;\n  upgradeSubscription?: Maybe<UpgradeSubscription>;\n  uploadEditableDocument?: Maybe<Scalars['Boolean']['output']>;\n  uploadToScanbot?: Maybe<ScanbotDocumentType>;\n  vestCliffOrPeriodicEsop?: Maybe<Scalars['Boolean']['output']>;\n  vestCliffOrPeriodicEss?: Maybe<Scalars['Boolean']['output']>;\n  vestCliffOrPeriodicFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  vestCliffOrPeriodicRsu?: Maybe<Scalars['Boolean']['output']>;\n  vestCliffOrPeriodicWarrant?: Maybe<Scalars['Boolean']['output']>;\n  vestOfferMilestonesEsop?: Maybe<Scalars['Boolean']['output']>;\n  vestOfferMilestonesEss?: Maybe<Scalars['Boolean']['output']>;\n  vestOfferMilestonesFounderVesting?: Maybe<Scalars['Boolean']['output']>;\n  vestOfferMilestonesRsu?: Maybe<Scalars['Boolean']['output']>;\n  vestOfferMilestonesWarrant?: Maybe<Scalars['Boolean']['output']>;\n  whitelistUserMfa?: Maybe<Scalars['Boolean']['output']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAcceptEquityOfferArgs = {\n  amount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAcceptNotesOfferArgs = {\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  principal?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAddBuyBackArgs = {\n  addBuyBackData: AddBuyBackInput;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAddEquityRoundOfferArgs = {\n  amount: Scalars['CakeDecimal']['input'];\n  reminderSentDate?: InputMaybe<Scalars['String']['input']>;\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n  shareholder: Scalars['ShareholderCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAddHistorical409AArgs = {\n  applyExercisePrice: Scalars['Boolean']['input'];\n  documentation?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  fairMarketValue: Scalars['CakeDecimal']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  valuationDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAddOfficeholderArgs = {\n  addOfficeholderData: AddOfficeholderData;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAddOrRenewSupportRoleArgs = {\n  organisationId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAddOrUpdateCompanySignersArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  signers: Array<InputMaybe<AddOrUpdateCompanySignersInput>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAddShareSplitArgs = {\n  shareType: Scalars['SharetypeCakeType']['input'];\n  splitDate: Scalars['Date']['input'];\n  splitFactor: Scalars['CakeDecimal']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAddShareholderArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareholderDataInputList: Array<InputMaybe<ShareholderDataInput>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAddShareholderIssueSharesArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareholderIssueSharesInputList: Array<InputMaybe<ShareholderIssueSharesInput>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAddSupportToShareholderArgs = {\n  shareholder: Scalars['ShareholderCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAddValuationArgs = {\n  date: Scalars['Date']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  round?: InputMaybe<Scalars['CleanString']['input']>;\n  valuation: Scalars['CakeDecimal']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationApplyHistorical409aStrikePriceArgs = {\n  esop: Scalars['EsopCakeType']['input'];\n  historical409a: Scalars['Historical409ACakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationApproveExerciseRequestArgs = {\n  exerciseRequest: Scalars['OptionExerciseRequestCakeType']['input'];\n  trustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAssignBareTrustEsopArgs = {\n  bareTrustTrustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  offers: Scalars['EsopOfferQuerySetCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAssignBareTrustEssArgs = {\n  bareTrustTrustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  offers: Scalars['EssOfferQuerySetCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAssignBareTrustFounderVestingArgs = {\n  bareTrustTrustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  offers: Scalars['FounderVestingOfferQuerySetCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAssignBareTrustRsuArgs = {\n  bareTrustTrustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  offers: Scalars['RsuOfferQuerySetCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationAssignBareTrustWarrantArgs = {\n  bareTrustTrustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  offers: Scalars['WarrantOfferQuerySetCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationBulkCreateOffersEsopArgs = {\n  group: Scalars['EsopOfferGroupCakeType']['input'];\n  offersList: Array<EsopOfferBulkEntryInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationBulkCreateOffersEssArgs = {\n  group: Scalars['EssOfferGroupCakeType']['input'];\n  offersList: Array<EssOfferBulkEntryInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationBulkCreateOffersRsuArgs = {\n  group: Scalars['RsuOfferGroupCakeType']['input'];\n  offersList: Array<RsuOfferBulkEntryInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationBulkCreateOffersWarrantArgs = {\n  group: Scalars['WarrantOfferGroupCakeType']['input'];\n  offersList: Array<WarrantOfferBulkEntryInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationBulkDeleteNotesArgs = {\n  noteIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationBuyOneOff409AArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationBuyOneOffQsbsArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCancelNoteArgs = {\n  cancellationType?: InputMaybe<Scalars['CleanString']['input']>;\n  date?: InputMaybe<Scalars['Date']['input']>;\n  noteId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationChangeOfferTemplateEsopArgs = {\n  contractType: ContractType;\n  offer: Scalars['EsopOfferCakeType']['input'];\n  template: Scalars['DocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationChangeOfferTemplateEssArgs = {\n  contractType: ContractType;\n  offer: Scalars['EssOfferCakeType']['input'];\n  template: Scalars['DocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationChangeOfferTemplateRsuArgs = {\n  contractType: ContractType;\n  offer: Scalars['RsuOfferCakeType']['input'];\n  template: Scalars['DocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationClearGroupOffersEsopArgs = {\n  group: Scalars['EsopOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationClearGroupOffersEssArgs = {\n  group: Scalars['EssOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationClearGroupOffersFounderVestingArgs = {\n  group: Scalars['FounderVestingOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationClearGroupOffersRsuArgs = {\n  group: Scalars['RsuOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationClearGroupOffersWarrantArgs = {\n  group: Scalars['WarrantOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationClearOffersEsopArgs = {\n  plan: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationClearOffersEssArgs = {\n  plan: Scalars['EssCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationClearOffersFounderVestingArgs = {\n  plan: Scalars['FounderVestingCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationClearOffersRsuArgs = {\n  plan: Scalars['RsuCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationClearOffersWarrantArgs = {\n  plan: Scalars['WarrantCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCompleteOfferEsopArgs = {\n  investorEmail?: InputMaybe<Scalars['CleanString']['input']>;\n  offer: Scalars['EsopOfferCakeType']['input'];\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCompleteOfferEssArgs = {\n  investorEmail?: InputMaybe<Scalars['CleanString']['input']>;\n  offer: Scalars['EssOfferCakeType']['input'];\n  sharePrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCompleteOfferRsuArgs = {\n  investorEmail?: InputMaybe<Scalars['CleanString']['input']>;\n  offer: Scalars['RsuOfferCakeType']['input'];\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCompleteShareTransferOfferArgs = {\n  certificateCount: Scalars['PositiveInteger']['input'];\n  transferDate: Scalars['Date']['input'];\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationConfirmEquityOfferInvestorDetailsArgs = {\n  investorData: ShareholderDataInput;\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationConfirmExercisePaymentAndIssueSharesArgs = {\n  exerciseRequest: Scalars['OptionExerciseRequestCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationConfirmNotesOfferInvestorDetailsArgs = {\n  investorData: ShareholderDataInput;\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationConfirmOfferInvestorDetailsEsopArgs = {\n  investorData: ShareholderDataInput;\n  investorTrustData?: InputMaybe<ShareholderDataInput>;\n  offer: Scalars['EsopOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationConfirmOfferInvestorDetailsEssArgs = {\n  investorData: ShareholderDataInput;\n  investorTrustData?: InputMaybe<ShareholderDataInput>;\n  offer: Scalars['EssOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationConfirmOfferInvestorDetailsRsuArgs = {\n  investorData: ShareholderDataInput;\n  investorTrustData?: InputMaybe<ShareholderDataInput>;\n  offer: Scalars['RsuOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationConfirmShareTransferOfferInvestorDetailsArgs = {\n  investorData: ShareholderDataInput;\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationConfirmUserInviteArgs = {\n  code: Scalars['String']['input'];\n  inviteId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationConvertNoteArgs = {\n  date?: InputMaybe<Scalars['Date']['input']>;\n  dryRun?: InputMaybe<Scalars['Boolean']['input']>;\n  noteId: Scalars['UUID']['input'];\n  pricePerShare: Scalars['CakeDecimal']['input'];\n  sharetypeId: Scalars['UUID']['input'];\n  valuation?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationConvertNoteManualArgs = {\n  conversionShares: Scalars['BigInt']['input'];\n  date?: InputMaybe<Scalars['Date']['input']>;\n  noteId: Scalars['UUID']['input'];\n  sharetypeId: Scalars['UUID']['input'];\n  totalAmountPaid?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationConvertSharesArgs = {\n  beneficiaryId?: InputMaybe<Scalars['UUID']['input']>;\n  conversionDate: Scalars['Date']['input'];\n  fromSharetypeId: Scalars['UUID']['input'];\n  numberOfShares: Scalars['PositiveInteger']['input'];\n  shareholderId: Scalars['UUID']['input'];\n  splitFactor?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  targetNumberOfShares?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  toSharetypeId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCopyMoveFileOrFolderArgs = {\n  destinationId?: InputMaybe<Scalars['UUID']['input']>;\n  isMove?: InputMaybe<Scalars['Boolean']['input']>;\n  sourceIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateBoardApprovalArgs = {\n  autoGrant: Scalars['Boolean']['input'];\n  esopOffers: Array<Scalars['EsopOfferCakeType']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  signers: Array<Scalars['OfficeholderCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateCakeGroupArgs = {\n  groupName: Scalars['String']['input'];\n  organisationId: Scalars['UUID']['input'];\n  parentGroupId?: InputMaybe<Scalars['UUID']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateCommentArgs = {\n  content: Scalars['String']['input'];\n  instanceId: Scalars['UUID']['input'];\n  modelType: CommentModelTypeEnum;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateDraftContractArgs = {\n  contractType: Scalars['String']['input'];\n  documentName?: InputMaybe<Scalars['String']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateEquityModelArgs = {\n  conversionMethodology?: InputMaybe<Scalars['CleanString']['input']>;\n  modelData: EquityModelDataInputType;\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateEquityRoundArgs = {\n  endDate: Scalars['Date']['input'];\n  existingShares: Scalars['PositiveIntegerOrZero']['input'];\n  isTrustAccount?: InputMaybe<Scalars['Boolean']['input']>;\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  payment?: InputMaybe<Scalars['JSONString']['input']>;\n  raiseGoalAmount: Scalars['CakeDecimal']['input'];\n  shareType: Scalars['SharetypeCakeType']['input'];\n  valuation: Scalars['ValuationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateEsopArgs = {\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  exercisePrice: Scalars['CakeDecimal']['input'];\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  offerLetterTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  optionPrice: Scalars['CakeDecimal']['input'];\n  planRulesTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  restrictionsOnShares?: InputMaybe<Array<InputMaybe<Scalars['CleanString']['input']>>>;\n  sharetype: Scalars['SharetypeCakeType']['input'];\n  valueOfClassOfShare?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  vestingValue: Scalars['PositiveInteger']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateEssArgs = {\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  offerLetterTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  planRulesTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype: Scalars['SharetypeCakeType']['input'];\n  vestingValue: Scalars['PositiveInteger']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateFolderArgs = {\n  names: Array<InputMaybe<Scalars['String']['input']>>;\n  organisationId: Scalars['UUID']['input'];\n  parentId?: InputMaybe<Scalars['String']['input']>;\n  useExisting?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateGroupEsopArgs = {\n  countryCode: Scalars['CleanString']['input'];\n  offerLetterTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  plan: Scalars['EsopCakeType']['input'];\n  planRulesTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateGroupEssArgs = {\n  countryCode: Scalars['CleanString']['input'];\n  offerLetterTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  plan: Scalars['EssCakeType']['input'];\n  planRulesTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateGroupRsuArgs = {\n  countryCode: Scalars['CleanString']['input'];\n  offerLetterTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  plan: Scalars['RsuCakeType']['input'];\n  planRulesTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateNoteArgs = {\n  comment?: InputMaybe<Scalars['String']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  interest?: InputMaybe<Interest>;\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  noteType: Scalars['String']['input'];\n  principal: Scalars['CakeDecimal']['input'];\n  shareholderId: Scalars['UUID']['input'];\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateNotesOfferArgs = {\n  contractTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  contractTemplateFromMaster?: InputMaybe<Scalars['Boolean']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  existingShareholder?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  newShareholder?: InputMaybe<InvestorAndEmployeeDataInput>;\n  noteType: Scalars['String']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  principal: Scalars['CakeDecimal']['input'];\n  round?: InputMaybe<Scalars['String']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateNotesOfferTemplateArgs = {\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateNotesRaiseAndOfficeholdersArgs = {\n  capitalRaisingEventAmount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  endDate: Scalars['Date']['input'];\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  name: Scalars['CleanString']['input'];\n  noteType: Scalars['String']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  payment?: InputMaybe<Scalars['JSONString']['input']>;\n  roundInvestmentGoal: Scalars['CakeDecimal']['input'];\n  signers: Array<InputMaybe<OfficeholderInput>>;\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateNotesRoundArgs = {\n  capitalRaisingEventAmount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  endDate?: InputMaybe<Scalars['Date']['input']>;\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  name: Scalars['CleanString']['input'];\n  noteType: Scalars['String']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  payment?: InputMaybe<Scalars['JSONString']['input']>;\n  roundInvestmentGoal: Scalars['CakeDecimal']['input'];\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateNotesRoundOfferArgs = {\n  principal: Scalars['CakeDecimal']['input'];\n  round: Scalars['NotesRoundCakeType']['input'];\n  shareholder: Scalars['ShareholderCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateNotesRoundTemplateArgs = {\n  baseTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  round: Scalars['NotesRoundCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateOffboardingArgs = {\n  offers: Array<OffboardingEntryInputType>;\n  shareholder: Scalars['ShareholderCakeType']['input'];\n  terminationDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateOfferEsopArgs = {\n  existingShareholders: Array<ShareholderEmployeeInput>;\n  newShareholders: Array<InvestorAndEmployeeDataInput>;\n  offerData: EsopOfferInputType;\n  offerGroup: Scalars['EsopOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateOfferEssArgs = {\n  existingShareholders: Array<ShareholderEmployeeInput>;\n  newShareholders: Array<InvestorAndEmployeeDataInput>;\n  offerData: EssOfferInputType;\n  offerGroup: Scalars['EssOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateOfferPauseEventEsopArgs = {\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['EsopOfferCakeType']['input'];\n  pauseDate: Scalars['Date']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateOfferPauseEventEssArgs = {\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['EssOfferCakeType']['input'];\n  pauseDate: Scalars['Date']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateOfferPauseEventFounderVestingArgs = {\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n  pauseDate: Scalars['Date']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateOfferPauseEventRsuArgs = {\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['RsuOfferCakeType']['input'];\n  pauseDate: Scalars['Date']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateOfferPauseEventWarrantArgs = {\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['WarrantOfferCakeType']['input'];\n  pauseDate: Scalars['Date']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateOfferRsuArgs = {\n  existingShareholders: Array<ShareholderEmployeeInput>;\n  newShareholders: Array<InvestorAndEmployeeDataInput>;\n  offerData: RsuOfferInputType;\n  offerGroup: Scalars['RsuOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateOfferWarrantArgs = {\n  existingShareholders: Array<ShareholderEmployeeInput>;\n  newShareholders: Array<InvestorAndEmployeeDataInput>;\n  offerData: WarrantOfferInputType;\n  offerGroup?: InputMaybe<Scalars['OfferGroupCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateOrganisationSignupArgs = {\n  companySize?: InputMaybe<Scalars['CleanString']['input']>;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  copilots?: InputMaybe<Array<InputMaybe<InvitedUserInput>>>;\n  country: Scalars['CleanString']['input'];\n  creationIntents?: InputMaybe<Array<Scalars['CleanString']['input']>>;\n  creatorRole?: InputMaybe<Scalars['CleanString']['input']>;\n  experienceLevel?: InputMaybe<Scalars['CleanString']['input']>;\n  fundingPhase?: InputMaybe<Scalars['CleanString']['input']>;\n  interestedIn409a?: InputMaybe<Scalars['Boolean']['input']>;\n  mobileNumber?: InputMaybe<Scalars['CleanString']['input']>;\n  name: Scalars['CleanString']['input'];\n  reasonForOnboarding?: InputMaybe<Scalars['CleanString']['input']>;\n  sourceOfReferral?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateRsuArgs = {\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  offerLetterTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  planRulesTemplateDocOrName?: InputMaybe<Scalars['CleanString']['input']>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype: Scalars['SharetypeCakeType']['input'];\n  vestingValue: Scalars['PositiveInteger']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateShareTransferOfferArgs = {\n  amount: Scalars['CakeDecimal']['input'];\n  fromShareholder: Scalars['ShareholderCakeType']['input'];\n  shareTransferRound: Scalars['ShareTransferRoundCakeType']['input'];\n  shares: Scalars['PositiveInteger']['input'];\n  sharetype: Scalars['SharetypeCakeType']['input'];\n  toShareholder: Scalars['ShareholderCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateShareTransferRoundArgs = {\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateShareTransferRoundTemplateArgs = {\n  baseTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  name?: InputMaybe<Scalars['String']['input']>;\n  templateType: Scalars['CleanString']['input'];\n  transferRound: Scalars['ShareTransferRoundCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateShareTypeArgs = {\n  createSharetypeData: CreateShareTypeInput;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateTemplateEsopArgs = {\n  baseTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  offerGroup: Scalars['EsopOfferGroupCakeType']['input'];\n  offerIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  templateType: Scalars['String']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateTemplateEssArgs = {\n  baseTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  offerGroup: Scalars['EssOfferGroupCakeType']['input'];\n  offerIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  templateType: Scalars['String']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateTemplateNoteArgs = {\n  baseTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  templateType: Scalars['String']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateTemplateRsuArgs = {\n  baseTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  offerGroup: Scalars['RsuOfferGroupCakeType']['input'];\n  offerIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  templateType: Scalars['String']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationCreateVestingScheduleTemplateArgs = {\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  vestingScheduleTemplate: VestingScheduleTemplateInputType;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDebugRefreshLicenseArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDebugReportUsageArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeclineEquityOfferArgs = {\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeclineNotesOfferArgs = {\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeclineOfferEsopArgs = {\n  offer: Scalars['EsopOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeclineOfferEssArgs = {\n  offer: Scalars['EssOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeclineOfferRsuArgs = {\n  offer: Scalars['RsuOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeclineShareTransferOfferArgs = {\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteAllSupportRolesArgs = {\n  expiredOnly?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteBoardApprovalArgs = {\n  boardApproval: Scalars['BoardApprovalCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteCakeGroupArgs = {\n  groupId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteCommentArgs = {\n  commentIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteDocumentArgs = {\n  documents: Array<Scalars['DocumentCakeType']['input']>;\n  forceDelete?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteEquityModelArgs = {\n  equityModel: Scalars['EquityModelCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteEquityRoundArgs = {\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteEquityRoundOfferArgs = {\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteEsopArgs = {\n  plan: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteEssArgs = {\n  plan: Scalars['EssCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteGroupEsopArgs = {\n  group: Scalars['EsopOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteGroupEssArgs = {\n  group: Scalars['EssOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteGroupRsuArgs = {\n  group: Scalars['RsuOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteHistorical409AArgs = {\n  historical409A: Scalars['Historical409ACakeType']['input'];\n  removeDocumentation: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteMessageArgs = {\n  message: Scalars['CakeMessageCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteNoteArgs = {\n  note: Scalars['NoteCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteNotesRoundArgs = {\n  round: Scalars['NotesRoundCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteNotesRoundOfferArgs = {\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteNotesRoundTemplateArgs = {\n  round: Scalars['NotesRoundCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOffboardingArgs = {\n  offboarding: Scalars['OffboardingCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOfferPauseEventEsopArgs = {\n  force?: InputMaybe<Scalars['Boolean']['input']>;\n  pauseEvent: Scalars['EsopOfferPauseEventCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOfferPauseEventEssArgs = {\n  force?: InputMaybe<Scalars['Boolean']['input']>;\n  pauseEvent: Scalars['EssOfferPauseEventCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOfferPauseEventFounderVestingArgs = {\n  force?: InputMaybe<Scalars['Boolean']['input']>;\n  pauseEvent: Scalars['FounderVestingOfferPauseEventCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOfferPauseEventRsuArgs = {\n  force?: InputMaybe<Scalars['Boolean']['input']>;\n  pauseEvent: Scalars['RsuOfferPauseEventCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOfferPauseEventWarrantArgs = {\n  force?: InputMaybe<Scalars['Boolean']['input']>;\n  pauseEvent: Scalars['WarrantOfferPauseEventCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOffersEsopArgs = {\n  offers: Array<InputMaybe<Scalars['EsopOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOffersEssArgs = {\n  offers: Array<InputMaybe<Scalars['EssOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOffersFounderVestingArgs = {\n  offers: Array<InputMaybe<Scalars['FounderVestingOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOffersRsuArgs = {\n  offers: Array<InputMaybe<Scalars['RsuOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOffersWarrantArgs = {\n  offers: Array<InputMaybe<Scalars['WarrantOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteOfficeholderArgs = {\n  officeholder: Scalars['OfficeholderCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteRsuArgs = {\n  plan: Scalars['RsuCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteScanbotDocumentArgs = {\n  scanbotDocument: Scalars['ScanbotDocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteShareCertificateDisclaimerArgs = {\n  disclaimer: Scalars['ShareCertificateDisclaimerCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteShareTransferOfferArgs = {\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteShareTransferRoundArgs = {\n  transferRound: Scalars['ShareTransferRoundCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteShareTransferRoundTemplateArgs = {\n  templateType: Scalars['CleanString']['input'];\n  transferRound: Scalars['ShareTransferRoundCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteShareholdersArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  searchString?: InputMaybe<Scalars['String']['input']>;\n  shareholders?: InputMaybe<Array<InputMaybe<Scalars['ShareholderCakeType']['input']>>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteSharetypeArgs = {\n  sharetype: Scalars['SharetypeCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteSupportRolesArgs = {\n  roleIdList: Array<InputMaybe<Scalars['UUID']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteSupportToShareholderArgs = {\n  shareholder: Scalars['ShareholderCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteTransactionsArgs = {\n  organisationId: Scalars['UUID']['input'];\n  transactionIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  transactionType?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteValuationArgs = {\n  valuation: Scalars['ValuationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationDeleteVestingScheduleTemplateArgs = {\n  vestingScheduleTemplate: Scalars['VestingScheduleTemplateCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditEquityModelArgs = {\n  conversionMethodology?: InputMaybe<Scalars['CleanString']['input']>;\n  equityModel: Scalars['EquityModelCakeType']['input'];\n  modelData?: InputMaybe<EquityModelDataInputType>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditEquityRoundArgs = {\n  endDate?: InputMaybe<Scalars['Date']['input']>;\n  existingShares?: InputMaybe<Scalars['PositiveIntegerOrZero']['input']>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  raiseGoalAmount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n  shareType?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditEsopArgs = {\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  plan: Scalars['EsopCakeType']['input'];\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n  vestingValue?: InputMaybe<Scalars['PositiveInteger']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditEssArgs = {\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  plan: Scalars['EssCakeType']['input'];\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n  vestingValue?: InputMaybe<Scalars['PositiveInteger']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditExerciseRequestSettingsArgs = {\n  approvers?: InputMaybe<Array<InputMaybe<Scalars['UserCakeType']['input']>>>;\n  canRequestExercise?: InputMaybe<Scalars['Boolean']['input']>;\n  exerciseRequestSettings: Scalars['OptionExerciseRequestSettingsCakeType']['input'];\n  paymentDetails?: InputMaybe<ExerciseRequestPaymentDetailsInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditGroupEsopArgs = {\n  allowEarlyExercise?: InputMaybe<Scalars['Boolean']['input']>;\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  enforceDisclosurePeriod?: InputMaybe<Scalars['Boolean']['input']>;\n  exerciseExpireData?: InputMaybe<ExerciseExpireDataInputType>;\n  exercisePrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  group: Scalars['EsopOfferGroupCakeType']['input'];\n  optionPrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  postTerminationExercisePeriod?: InputMaybe<TimeSliceInputType>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  restrictionsOnShares?: InputMaybe<Array<InputMaybe<Scalars['CleanString']['input']>>>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  useGroupCurrency?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditGroupEssArgs = {\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  enforceDisclosurePeriod?: InputMaybe<Scalars['Boolean']['input']>;\n  group: Scalars['EssOfferGroupCakeType']['input'];\n  loanFunded?: InputMaybe<Scalars['Boolean']['input']>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditGroupRsuArgs = {\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  enforceDisclosurePeriod?: InputMaybe<Scalars['Boolean']['input']>;\n  group: Scalars['RsuOfferGroupCakeType']['input'];\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditGroupWarrantArgs = {\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  enforceDisclosurePeriod?: InputMaybe<Scalars['Boolean']['input']>;\n  group: Scalars['WarrantOfferGroupCakeType']['input'];\n  loanFunded?: InputMaybe<Scalars['Boolean']['input']>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditNoteArgs = {\n  comment?: InputMaybe<Scalars['CleanString']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  interest?: InputMaybe<Interest>;\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  note: Scalars['NoteCakeType']['input'];\n  principal?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditNotesOfferArgs = {\n  contractTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  noteType: Scalars['String']['input'];\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  principal: Scalars['CakeDecimal']['input'];\n  round?: InputMaybe<Scalars['String']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditNotesRoundArgs = {\n  capitalRaisingEventAmount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  endDate?: InputMaybe<Scalars['Date']['input']>;\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  round: Scalars['NotesRoundCakeType']['input'];\n  roundInvestmentGoal?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditOffboardingArgs = {\n  offboarding: Scalars['OffboardingCakeType']['input'];\n  offers: Array<OffboardingEntryInputType>;\n  terminationDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditOfferPauseEventEsopArgs = {\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n  pauseDate: Scalars['Date']['input'];\n  pauseEvent: Scalars['EsopOfferPauseEventCakeType']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditOfferPauseEventEssArgs = {\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n  pauseDate: Scalars['Date']['input'];\n  pauseEvent: Scalars['EssOfferPauseEventCakeType']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditOfferPauseEventFounderVestingArgs = {\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n  pauseDate: Scalars['Date']['input'];\n  pauseEvent: Scalars['FounderVestingOfferPauseEventCakeType']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditOfferPauseEventRsuArgs = {\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n  pauseDate: Scalars['Date']['input'];\n  pauseEvent: Scalars['RsuOfferPauseEventCakeType']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditOfferPauseEventWarrantArgs = {\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n  pauseDate: Scalars['Date']['input'];\n  pauseEvent: Scalars['WarrantOfferPauseEventCakeType']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditOnboardedShareholdersArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareholderIssueSharesInputList: Array<ShareholderIssueSharesInput>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantExercisePriceEsopArgs = {\n  attachment?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  exercisePrice: Scalars['CakeDecimal']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['EsopCakeType']['input'];\n  repriceTransactionDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantExercisePriceEssArgs = {\n  attachment?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  exercisePrice: Scalars['CakeDecimal']['input'];\n  offerGroup?: InputMaybe<Scalars['EssOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['EssCakeType']['input'];\n  repriceTransactionDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantExercisePriceFounderVestingArgs = {\n  attachment?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  exercisePrice: Scalars['CakeDecimal']['input'];\n  offerGroup?: InputMaybe<Scalars['FounderVestingOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['FounderVestingCakeType']['input'];\n  repriceTransactionDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantExercisePriceRsuArgs = {\n  attachment?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  exercisePrice: Scalars['CakeDecimal']['input'];\n  offerGroup?: InputMaybe<Scalars['RsuOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['RsuCakeType']['input'];\n  repriceTransactionDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantExercisePriceWarrantArgs = {\n  attachment?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  exercisePrice: Scalars['CakeDecimal']['input'];\n  offerGroup?: InputMaybe<Scalars['WarrantOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['WarrantCakeType']['input'];\n  repriceTransactionDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantExpirationEsopArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  exerciseExpirationData: OfferExerciseExpirationDataInputType;\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantGrantDateEsopArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  grantDate: Scalars['Date']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantGrantDateEssArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  grantDate: Scalars['Date']['input'];\n  offerGroup?: InputMaybe<Scalars['EssOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['EssCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantGrantDateFounderVestingArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  grantDate: Scalars['Date']['input'];\n  offerGroup?: InputMaybe<Scalars['FounderVestingOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['FounderVestingCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantGrantDateRsuArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  grantDate: Scalars['Date']['input'];\n  offerGroup?: InputMaybe<Scalars['RsuOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['RsuCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantGrantDateWarrantArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  grantDate: Scalars['Date']['input'];\n  offerGroup?: InputMaybe<Scalars['WarrantOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['WarrantCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantOptionPriceEsopArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  optionPrice: Scalars['CakeDecimal']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantPtepEsopArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['EsopCakeType']['input'];\n  ptep?: InputMaybe<TimeSliceInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantPtepEssArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  offerGroup?: InputMaybe<Scalars['EssOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['EssCakeType']['input'];\n  ptep?: InputMaybe<TimeSliceInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantPtepFounderVestingArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  offerGroup?: InputMaybe<Scalars['FounderVestingOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['FounderVestingCakeType']['input'];\n  ptep?: InputMaybe<TimeSliceInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantPtepRsuArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  offerGroup?: InputMaybe<Scalars['RsuOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['RsuCakeType']['input'];\n  ptep?: InputMaybe<TimeSliceInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantPtepWarrantArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  offerGroup?: InputMaybe<Scalars['WarrantOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  plan: Scalars['WarrantCakeType']['input'];\n  ptep?: InputMaybe<TimeSliceInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantVestStartDateEsopArgs = {\n  offer: Scalars['EsopOfferCakeType']['input'];\n  vestStartDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantVestStartDateEssArgs = {\n  offer: Scalars['EssOfferCakeType']['input'];\n  vestStartDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantVestStartDateFounderVestingArgs = {\n  offer: Scalars['FounderVestingCakeType']['input'];\n  vestStartDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantVestStartDateRsuArgs = {\n  offer: Scalars['RsuOfferCakeType']['input'];\n  vestStartDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditPostGrantVestStartDateWarrantArgs = {\n  offer: Scalars['WarrantCakeType']['input'];\n  vestStartDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditRsuArgs = {\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  plan: Scalars['RsuCakeType']['input'];\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n  vestingValue?: InputMaybe<Scalars['PositiveInteger']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditShareTransferOfferArgs = {\n  amount: Scalars['CakeDecimal']['input'];\n  fromShareholder: Scalars['ShareholderCakeType']['input'];\n  shares: Scalars['PositiveInteger']['input'];\n  sharetype: Scalars['SharetypeCakeType']['input'];\n  toShareholder: Scalars['ShareholderCakeType']['input'];\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditShareTransferRoundArgs = {\n  name: Scalars['CleanString']['input'];\n  transferRound: Scalars['ShareTransferRoundCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditTransactionArgs = {\n  amount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  shareholdingTransaction: Scalars['ShareholdingTransactionCakeType']['input'];\n  shares?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  transactionDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEditVestingScheduleTemplateArgs = {\n  name: Scalars['CleanString']['input'];\n  template: Scalars['VestingScheduleTemplateCakeType']['input'];\n  vestingScheduleTemplate: VestingScheduleTemplateInputType;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEnableDisableAutoVestEsopArgs = {\n  enabled: Scalars['Boolean']['input'];\n  offer: Scalars['EsopOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEnableDisableAutoVestEssArgs = {\n  enabled: Scalars['Boolean']['input'];\n  offer: Scalars['EssOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEnableDisableAutoVestFounderVestingArgs = {\n  enabled: Scalars['Boolean']['input'];\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEnableDisableAutoVestRsuArgs = {\n  enabled: Scalars['Boolean']['input'];\n  offer: Scalars['RsuOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationEnableDisableAutoVestWarrantArgs = {\n  enabled: Scalars['Boolean']['input'];\n  offer: Scalars['WarrantOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationExerciseOptionsEsopArgs = {\n  convertedExercisePrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  notify83bDeadline?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['EsopOfferCakeType']['input'];\n  options: Scalars['PositiveIntegerOrZero']['input'];\n  transactionDate: Scalars['Date']['input'];\n  trustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationExerciseWarrantsArgs = {\n  convertedExercisePrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  offer: Scalars['WarrantOfferCakeType']['input'];\n  options: Scalars['PositiveIntegerOrZero']['input'];\n  transactionDate: Scalars['Date']['input'];\n  trustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationFinaliseTemplateArgs = {\n  document: Scalars['DocumentCakeType']['input'];\n  revert?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationFixContractTemplatePlaceholdersArgs = {\n  document: Scalars['DocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationForceUpdateSigningStatusArgs = {\n  document: Scalars['DocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationFullyLapseOfferEsopArgs = {\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['EsopOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationFullyLapseOfferEssArgs = {\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['EssOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationFullyLapseOfferFounderVestingArgs = {\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationFullyLapseOfferRsuArgs = {\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['RsuOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationFullyLapseOfferWarrantArgs = {\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['WarrantOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGenerateQsbsReportForTransactionsArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  qsbsForm: QsbsFormInputType;\n  transactionIds: Array<Scalars['UUID']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGenerateShareCertificateByCriteriaArgs = {\n  certificateIssueDate?: InputMaybe<Scalars['Date']['input']>;\n  certificateNumber: Scalars['Int']['input'];\n  filterDate?: InputMaybe<Scalars['Date']['input']>;\n  filterDateIsGte?: InputMaybe<Scalars['Boolean']['input']>;\n  filterShareType?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  notifyShareholder?: InputMaybe<Scalars['Boolean']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGenerateShareCertificatesFromHoldingsArgs = {\n  certificateNumber: Scalars['Int']['input'];\n  disclaimersBySharetype?: InputMaybe<Array<InputMaybe<SharetypeDisclaimerInputType>>>;\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  notifyShareholder?: InputMaybe<Scalars['Boolean']['input']>;\n  organisation?: InputMaybe<Scalars['OrganisationCakeType']['input']>;\n  selectionSearch?: InputMaybe<Scalars['String']['input']>;\n  shareholders: Array<InputMaybe<Scalars['ShareholderCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGenerateTransactionalShareCertificateArgs = {\n  certificateNumber: Scalars['PositiveInteger']['input'];\n  disclaimerBySharetype?: InputMaybe<SharetypeDisclaimerInputType>;\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  transaction: Scalars['ShareholdingTransactionCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGenerateUsIrsForm3921Args = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGrantOfferEsopArgs = {\n  grantDate: Scalars['Date']['input'];\n  offer: Scalars['EsopOfferCakeType']['input'];\n  offerLetterId?: InputMaybe<Scalars['UUID']['input']>;\n  planRulesId?: InputMaybe<Scalars['UUID']['input']>;\n  vestingEmails?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGrantOfferEssArgs = {\n  amount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  grantDate: Scalars['Date']['input'];\n  offer: Scalars['EssOfferCakeType']['input'];\n  offerLetterId?: InputMaybe<Scalars['UUID']['input']>;\n  planRulesId?: InputMaybe<Scalars['UUID']['input']>;\n  trustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  vestingEmails?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGrantOfferFounderVestingArgs = {\n  amount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  grantDate: Scalars['Date']['input'];\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n  offerLetterId?: InputMaybe<Scalars['UUID']['input']>;\n  planRulesId?: InputMaybe<Scalars['UUID']['input']>;\n  trustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  unpaidAmount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  vestingEmails?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGrantOfferRsuArgs = {\n  amount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  grantDate: Scalars['Date']['input'];\n  offer: Scalars['RsuOfferCakeType']['input'];\n  offerLetterId?: InputMaybe<Scalars['UUID']['input']>;\n  planRulesId?: InputMaybe<Scalars['UUID']['input']>;\n  trustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  vestingEmails?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGrantOfferWarrantArgs = {\n  grantDate: Scalars['Date']['input'];\n  offer: Scalars['WarrantOfferCakeType']['input'];\n  offerLetterId?: InputMaybe<Scalars['UUID']['input']>;\n  planRulesId?: InputMaybe<Scalars['UUID']['input']>;\n  vestingEmails?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGrantOffersEsopArgs = {\n  grantDate: Scalars['Date']['input'];\n  offers: Scalars['EsopOfferQuerySetCakeType']['input'];\n  vestingEmails?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGrantOffersEssArgs = {\n  grantDate: Scalars['Date']['input'];\n  offers: Scalars['EssOfferQuerySetCakeType']['input'];\n  vestingEmails?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGrantOffersRsuArgs = {\n  grantDate: Scalars['Date']['input'];\n  offers: Scalars['RsuOfferQuerySetCakeType']['input'];\n  vestingEmails?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationGrantOffersWarrantArgs = {\n  grantDate: Scalars['Date']['input'];\n  offers: Scalars['WarrantOfferQuerySetCakeType']['input'];\n  vestingEmails?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteAllOffersEsopArgs = {\n  planOrGroupId: Scalars['UUID']['input'];\n  sendEmail?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteEquityOfferArgs = {\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  sendInvitationEmail?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteJoinCakeArgs = {\n  emailsForInvestors?: InputMaybe<Array<InputMaybe<InvitedShareholderEmailInput>>>;\n  investorIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  selectionSearch?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteNotesOfferArgs = {\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  payment?: InputMaybe<Scalars['JSONString']['input']>;\n  sendInvitationEmail?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteOfferEsopArgs = {\n  offer: Scalars['EsopOfferCakeType']['input'];\n  offerLetterTemplate: Scalars['DocumentCakeType']['input'];\n  planRulesTemplate: Scalars['DocumentCakeType']['input'];\n  sendInvitationEmail?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteOfferEssArgs = {\n  offer: Scalars['EssOfferCakeType']['input'];\n  offerLetterTemplate: Scalars['DocumentCakeType']['input'];\n  planRulesTemplate: Scalars['DocumentCakeType']['input'];\n  sendInvitationEmail?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteOfferRsuArgs = {\n  offer: Scalars['RsuOfferCakeType']['input'];\n  offerLetterTemplate: Scalars['DocumentCakeType']['input'];\n  planRulesTemplate: Scalars['DocumentCakeType']['input'];\n  sendInvitationEmail?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteOffersEsopArgs = {\n  offers: Array<InputMaybe<Scalars['EsopOfferCakeType']['input']>>;\n  sendEmail?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteOffersEssArgs = {\n  offers: Array<InputMaybe<Scalars['EssOfferCakeType']['input']>>;\n  sendEmail?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteOffersRsuArgs = {\n  offers: Array<InputMaybe<Scalars['RsuOfferCakeType']['input']>>;\n  sendEmail?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteShareTransferOfferArgs = {\n  sendInvitationEmail?: InputMaybe<Scalars['Boolean']['input']>;\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationInviteUsersArgs = {\n  invitedUsers: Array<InputMaybe<InvitedUserInput>>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationIssueOfferNoteArgs = {\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationIssueOfferSharesArgs = {\n  certificateCount: Scalars['Int']['input'];\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationIssueSharesArgs = {\n  issueSharesInputList: Array<InputMaybe<IssueSharesInput>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationIssueSharesFounderVestingArgs = {\n  issueSharesInput: IssueSharesInput;\n  offerData: OfferInputType;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationIssueSharesWarrantArgs = {\n  issueSharesInput: IssueSharesInput;\n  offerData: OfferInputType;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationLapseMilestoneEsopArgs = {\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  lapseDate: Scalars['Date']['input'];\n  milestoneEvents: Array<LapseMilestoneEntryInputType>;\n  offer: Scalars['EsopOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationLapseMilestoneEssArgs = {\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  lapseDate: Scalars['Date']['input'];\n  milestoneEvents: Array<LapseMilestoneEntryInputType>;\n  offer: Scalars['EssOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationLapseMilestoneFounderVestingArgs = {\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  lapseDate: Scalars['Date']['input'];\n  milestoneEvents: Array<LapseMilestoneEntryInputType>;\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationLapseMilestoneRsuArgs = {\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  lapseDate: Scalars['Date']['input'];\n  milestoneEvents: Array<LapseMilestoneEntryInputType>;\n  offer: Scalars['RsuOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationLapseMilestoneWarrantArgs = {\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  lapseDate: Scalars['Date']['input'];\n  milestoneEvents: Array<LapseMilestoneEntryInputType>;\n  offer: Scalars['WarrantOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationLapseOfferEsopArgs = {\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  lapseDate: Scalars['Date']['input'];\n  offer: Scalars['EsopOfferCakeType']['input'];\n  periodicOnly?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationLapseOfferEssArgs = {\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  lapseDate: Scalars['Date']['input'];\n  offer: Scalars['EssOfferCakeType']['input'];\n  periodicOnly?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationLapseOfferFounderVestingArgs = {\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  lapseDate: Scalars['Date']['input'];\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n  periodicOnly?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationLapseOfferRsuArgs = {\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  lapseDate: Scalars['Date']['input'];\n  offer: Scalars['RsuOfferCakeType']['input'];\n  periodicOnly?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationLapseOfferWarrantArgs = {\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n  forceLapse?: InputMaybe<Scalars['Boolean']['input']>;\n  lapseDate: Scalars['Date']['input'];\n  offer: Scalars['WarrantOfferCakeType']['input'];\n  periodicOnly?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationMergeStakeholdersArgs = {\n  obsoleteShareholder: Scalars['ShareholderCakeType']['input'];\n  prevalentShareholder: Scalars['ShareholderCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationMoveFromSigningToDocumentsArgs = {\n  documentId: Scalars['UUID']['input'];\n  folder?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationMoveOffersEsopArgs = {\n  offers: Array<Scalars['UUID']['input']>;\n  plan: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationMoveOffersEssArgs = {\n  offers: Array<Scalars['UUID']['input']>;\n  plan: Scalars['EssCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationMoveOffersRsuArgs = {\n  offers: Array<Scalars['UUID']['input']>;\n  plan: Scalars['RsuCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOnOffAutoVestEmailsAllEsopArgs = {\n  emailsOn: Scalars['Boolean']['input'];\n  planOrGroupId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOnOffAutoVestEmailsAllEssArgs = {\n  emailsOn: Scalars['Boolean']['input'];\n  planOrGroupId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOnOffAutoVestEmailsAllFounderVestingArgs = {\n  emailsOn: Scalars['Boolean']['input'];\n  planOrGroupId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOnOffAutoVestEmailsAllRsuArgs = {\n  emailsOn: Scalars['Boolean']['input'];\n  planOrGroupId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOnOffAutoVestEmailsAllWarrantArgs = {\n  emailsOn: Scalars['Boolean']['input'];\n  planOrGroupId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOnOffAutoVestEmailsEsopArgs = {\n  emailsOn: Scalars['Boolean']['input'];\n  offers: Array<InputMaybe<Scalars['EsopOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOnOffAutoVestEmailsEssArgs = {\n  emailsOn: Scalars['Boolean']['input'];\n  offers: Array<InputMaybe<Scalars['EssOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOnOffAutoVestEmailsFounderVestingArgs = {\n  emailsOn: Scalars['Boolean']['input'];\n  offers: Array<InputMaybe<Scalars['FounderVestingOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOnOffAutoVestEmailsRsuArgs = {\n  emailsOn: Scalars['Boolean']['input'];\n  offers: Array<InputMaybe<Scalars['RsuOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOnOffAutoVestEmailsWarrantArgs = {\n  emailsOn: Scalars['Boolean']['input'];\n  offers: Array<InputMaybe<Scalars['WarrantOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOnboardingShownArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationOverrideDelinquentLockArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  override: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationPauseSubscriptionArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  pause: Scalars['Boolean']['input'];\n  reasonForPause?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationPayPendingInvoicesArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRefreshScanbotStatusArgs = {\n  scanbotDocument: Scalars['ScanbotDocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRejectExerciseRequestArgs = {\n  exerciseRequest: Scalars['OptionExerciseRequestCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRemindAllOffersArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRemoveOrganisationUserRolesArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  user: Scalars['UserCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRemoveShareDocumentArgs = {\n  documentId: Scalars['UUID']['input'];\n  shareholderOrGroupId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRenameDocumentArgs = {\n  documentId: Scalars['UUID']['input'];\n  newName: Scalars['String']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRepayNoteArgs = {\n  date?: InputMaybe<Scalars['Date']['input']>;\n  noteId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRequestCancelSubscriptionArgs = {\n  competitorName?: InputMaybe<Scalars['String']['input']>;\n  feedback?: InputMaybe<Scalars['String']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  reason: Scalars['CleanString']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRequestEmailChangeArgs = {\n  newEmail: Scalars['CleanString']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRequestExerciseArgs = {\n  offer: Scalars['EsopOfferCakeType']['input'];\n  options: Scalars['PositiveInteger']['input'];\n  taxWithholding?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationResetNotesOfferArgs = {\n  keepContracts?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationResetOffersEsopArgs = {\n  keepContracts?: InputMaybe<Scalars['Boolean']['input']>;\n  offers: Array<Scalars['EsopOfferCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationResetOffersEssArgs = {\n  keepContracts?: InputMaybe<Scalars['Boolean']['input']>;\n  offers: Array<Scalars['EssOfferCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationResetOffersFounderVestingArgs = {\n  keepContracts?: InputMaybe<Scalars['Boolean']['input']>;\n  offers: Array<Scalars['FounderVestingOfferCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationResetOffersRsuArgs = {\n  keepContracts?: InputMaybe<Scalars['Boolean']['input']>;\n  offers: Array<Scalars['RsuOfferCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationResetOffersWarrantArgs = {\n  keepContracts?: InputMaybe<Scalars['Boolean']['input']>;\n  offers: Array<Scalars['WarrantOfferCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationResetUserMfaEnrollArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  userId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRevertCancelSubscriptionArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationRevokeUserInvitationArgs = {\n  invite: Scalars['EmailSenderCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSaveMessageArgs = {\n  allowReactions?: InputMaybe<Scalars['Boolean']['input']>;\n  allowReplies?: InputMaybe<Scalars['Boolean']['input']>;\n  attachments?: InputMaybe<Array<InputMaybe<Scalars['DocumentCakeType']['input']>>>;\n  body?: InputMaybe<Scalars['String']['input']>;\n  fromShareholder?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  groups: Array<InputMaybe<Scalars['CakeGroupCakeType']['input']>>;\n  message?: InputMaybe<Scalars['CakeMessageCakeType']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  replyThread?: InputMaybe<Scalars['CakeReplyThreadCakeType']['input']>;\n  rootMessage?: InputMaybe<Scalars['CakeMessageCakeType']['input']>;\n  shareholders: Array<InputMaybe<Scalars['ShareholderCakeType']['input']>>;\n  subject?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSaveShareCertificateDisclaimerArgs = {\n  disclaimer?: InputMaybe<Scalars['ShareCertificateDisclaimerCakeType']['input']>;\n  disclaimerText: Scalars['CleanString']['input'];\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  sharetypeDefault?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSend409aProviderNotificationArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendActivityLogFeedbackArgs = {\n  activityLogFeedback?: InputMaybe<Scalars['CleanString']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendAsc718RequestArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendBoardApprovalReminderArgs = {\n  boardApproval: Scalars['BoardApprovalCakeType']['input'];\n  signerEmail?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendCakeTestKitchenEmailArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendCaptableDocumentUploadEmailsArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendChurnDiscountRequestArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendContractForSigningEsopArgs = {\n  contractType: Scalars['String']['input'];\n  esopOfferGroup: Scalars['EsopOfferGroupCakeType']['input'];\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendEmployeeLicenseBlockEmailArgs = {\n  organisationId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendEsopDocumentUploadEmailsArgs = {\n  documentId: Scalars['UUID']['input'];\n  documentName: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendKudosArgs = {\n  actionType: Scalars['CleanString']['input'];\n  offerId: Scalars['UUID']['input'];\n  selectedBadge: Scalars['CleanString']['input'];\n  userMessage?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendMessageArgs = {\n  allowReactions?: InputMaybe<Scalars['Boolean']['input']>;\n  allowReplies?: InputMaybe<Scalars['Boolean']['input']>;\n  attachments?: InputMaybe<Array<InputMaybe<Scalars['DocumentCakeType']['input']>>>;\n  body: Scalars['CleanString']['input'];\n  fromShareholder?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  groups: Array<InputMaybe<Scalars['CakeGroupCakeType']['input']>>;\n  message?: InputMaybe<Scalars['CakeMessageCakeType']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  replyThread?: InputMaybe<Scalars['CakeReplyThreadCakeType']['input']>;\n  rootMessage?: InputMaybe<Scalars['CakeMessageCakeType']['input']>;\n  shareholders: Array<InputMaybe<Scalars['ShareholderCakeType']['input']>>;\n  subject?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendRequest409aCallbackArgs = {\n  mobileNumber: Scalars['String']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSendTestTransactionalEmailArgs = {\n  organisationId: Scalars['UUID']['input'];\n  templateSlug?: InputMaybe<CustomerIoMailTemplates>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSetLoanFundedAllEssArgs = {\n  loanFunded: Scalars['Boolean']['input'];\n  planOrGroupId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSetLoanFundedAllFounderVestingArgs = {\n  loanFunded: Scalars['Boolean']['input'];\n  planOrGroupId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSetLoanFundedEssArgs = {\n  loanFunded: Scalars['Boolean']['input'];\n  offers: Array<InputMaybe<Scalars['EssOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSetLoanFundedFounderVestingArgs = {\n  loanFunded: Scalars['Boolean']['input'];\n  offers: Array<InputMaybe<Scalars['FounderVestingOfferCakeType']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSetNotesOfferTemplateArgs = {\n  contractTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSetNotesRoundTemplateArgs = {\n  contractTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  round: Scalars['NotesRoundCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSetUserEmployeeGoalArgs = {\n  emotion: Scalars['CleanString']['input'];\n  goal: Scalars['CleanString']['input'];\n  meaning: Scalars['CleanString']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSetUserPreferenceArgs = {\n  name: Scalars['String']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  value: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSettleEquityOfferOfflineArgs = {\n  amount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  contract?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSettleExerciseRequestOfflineArgs = {\n  exerciseDate: Scalars['Date']['input'];\n  exerciseNotice?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  exerciseRequest: Scalars['OptionExerciseRequestCakeType']['input'];\n  trustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSettleNotesOfferOfflineArgs = {\n  contract?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  notify?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  principal?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSettleShareTransferOfferOfflineArgs = {\n  contract?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSetupExerciseRequestSettingsArgs = {\n  approvers: Array<InputMaybe<Scalars['UserCakeType']['input']>>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  paymentDetails: ExerciseRequestPaymentDetailsInputType;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSetupSharetypesArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  sharetypes: Array<CreateOrUpdateSharetypeInput>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationShareDocumentArgs = {\n  documentId: Scalars['UUID']['input'];\n  shareholderOrGroupId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSignNoteAgreementArgs = {\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  witness?: InputMaybe<WitnessInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSignNoteAgreementOfficeholderArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSignOfferLetterEsopArgs = {\n  offer: Scalars['EsopOfferCakeType']['input'];\n  witness?: InputMaybe<WitnessInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSignOfferLetterEssArgs = {\n  offer: Scalars['EssOfferCakeType']['input'];\n  witness?: InputMaybe<WitnessInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSignOfferLetterRsuArgs = {\n  offer: Scalars['RsuOfferCakeType']['input'];\n  witness?: InputMaybe<WitnessInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSignShareTransferAgreementArgs = {\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSignSubscriptionAgreementArgs = {\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  witness?: InputMaybe<WitnessInputType>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSignSubscriptionAgreementOfficeholderArgs = {\n  raiseOfferId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationStartContractSigningArgs = {\n  document: Scalars['DocumentCakeType']['input'];\n  emailBody: Scalars['CleanString']['input'];\n  emailSubject: Scalars['CleanString']['input'];\n  groupSigners?: InputMaybe<Array<InputMaybe<Scalars['CakeGroupCakeType']['input']>>>;\n  officeholderSigners?: InputMaybe<Array<InputMaybe<Scalars['OfficeholderCakeType']['input']>>>;\n  shareholderSigners?: InputMaybe<Array<InputMaybe<Scalars['ShareholderCakeType']['input']>>>;\n  userSigners?: InputMaybe<Array<InputMaybe<Scalars['UserCakeType']['input']>>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSubmitExercisePaymentArgs = {\n  exerciseRequest: Scalars['OptionExerciseRequestCakeType']['input'];\n  signature?: InputMaybe<Scalars['String']['input']>;\n  variant?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSupportDeleteOrganisationArgs = {\n  confirmation: Scalars['String']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  reason: Scalars['CleanString']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationSyncWithMasterTemplateArgs = {\n  document: Scalars['DocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleAllowEarlyExerciseAllEsopArgs = {\n  allowEarlyExercise: Scalars['Boolean']['input'];\n  planOrGroupId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleAllowEarlyExerciseEsopArgs = {\n  allowEarlyExercise: Scalars['Boolean']['input'];\n  offers: Array<Scalars['EsopOfferCakeType']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleAssignConversionLockRsuArgs = {\n  description?: InputMaybe<Scalars['CleanString']['input']>;\n  offers: Scalars['RsuOfferQuerySetCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleCompleteConversionLockRsuArgs = {\n  conversionLockEvents: Scalars['RsuConversionLockEventQuerySetCakeType']['input'];\n  date?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleDisclosurePeriodEsopArgs = {\n  enforceDisclosurePeriod: Scalars['Boolean']['input'];\n  offerGroup: Scalars['EsopOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleDisclosurePeriodEssArgs = {\n  enforceDisclosurePeriod: Scalars['Boolean']['input'];\n  offerGroup: Scalars['EssOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleDisclosurePeriodFounderVestingArgs = {\n  enforceDisclosurePeriod: Scalars['Boolean']['input'];\n  offerGroup: Scalars['FounderVestingOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleDisclosurePeriodRsuArgs = {\n  enforceDisclosurePeriod: Scalars['Boolean']['input'];\n  offerGroup: Scalars['RsuOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleDisclosurePeriodWarrantArgs = {\n  enforceDisclosurePeriod: Scalars['Boolean']['input'];\n  offerGroup: Scalars['WarrantOfferGroupCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleMessageAllowRepliesArgs = {\n  allowReplies: Scalars['Boolean']['input'];\n  message: Scalars['CakeMessageCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleMfaRequiredArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  otpCode?: InputMaybe<Scalars['CleanString']['input']>;\n  required: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleOrganisationAllowRepliesArgs = {\n  allowReplies: Scalars['Boolean']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleWitnessOfferLetterAllEsopArgs = {\n  planOrGroupId: Scalars['UUID']['input'];\n  requireWitness: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleWitnessOfferLetterAllEssArgs = {\n  planOrGroupId: Scalars['UUID']['input'];\n  requireWitness: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleWitnessOfferLetterAllRsuArgs = {\n  planOrGroupId: Scalars['UUID']['input'];\n  requireWitness: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleWitnessOfferLetterEsopArgs = {\n  offers: Array<InputMaybe<Scalars['EsopOfferCakeType']['input']>>;\n  requireWitness: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleWitnessOfferLetterEssArgs = {\n  offers: Array<InputMaybe<Scalars['EssOfferCakeType']['input']>>;\n  requireWitness: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleWitnessOfferLetterRsuArgs = {\n  offers: Array<InputMaybe<Scalars['RsuOfferCakeType']['input']>>;\n  requireWitness: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleWitnessOfferNoteArgs = {\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  requireWitness: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationToggleWitnessSubscriptionAgreementArgs = {\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  requireWitness: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationTouchOffersArgs = {\n  offerIds: Array<Scalars['UUID']['input']>;\n  remind?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationTransferSharesArgs = {\n  transferSharesData: TransferSharesData;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdate83bFormDownloadStatusArgs = {\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateBillingContactArgs = {\n  email: Scalars['CleanString']['input'];\n  mobile?: InputMaybe<Scalars['CleanString']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateCakeGroupArgs = {\n  groupId: Scalars['UUID']['input'];\n  groupName?: InputMaybe<Scalars['String']['input']>;\n  toAdd?: InputMaybe<Array<InputMaybe<GroupUserInputType>>>;\n  toRemove?: InputMaybe<Array<InputMaybe<GroupUserInputType>>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateContractEmailArgs = {\n  body: Scalars['String']['input'];\n  documentId: Scalars['UUID']['input'];\n  subject: Scalars['String']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateCreditCardArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  stripeId: Scalars['CleanString']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateEquityOfferPaymentStatusArgs = {\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  paid: Scalars['CakeDecimal']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateEquityRoundBankDetailsAuArgs = {\n  accountName?: InputMaybe<Scalars['String']['input']>;\n  isTrustAccount?: InputMaybe<Scalars['Boolean']['input']>;\n  paymentAccount?: InputMaybe<Scalars['String']['input']>;\n  paymentBsb?: InputMaybe<Scalars['String']['input']>;\n  paymentReference?: InputMaybe<Scalars['String']['input']>;\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateEquityRoundBankDetailsFallbackArgs = {\n  details?: InputMaybe<Scalars['String']['input']>;\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateEquityRoundBankDetailsSgArgs = {\n  accountName?: InputMaybe<Scalars['String']['input']>;\n  accountNumber?: InputMaybe<Scalars['String']['input']>;\n  bankCode?: InputMaybe<Scalars['String']['input']>;\n  branchCode?: InputMaybe<Scalars['String']['input']>;\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n  swiftCode?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateGroupDefaultTemplateEsopArgs = {\n  group: Scalars['EsopOfferGroupCakeType']['input'];\n  template: Scalars['DocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateGroupDefaultTemplateEssArgs = {\n  group: Scalars['EssOfferGroupCakeType']['input'];\n  template: Scalars['DocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateGroupDefaultTemplateRsuArgs = {\n  group: Scalars['RsuOfferGroupCakeType']['input'];\n  template: Scalars['DocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateHubspotMobileNumberArgs = {\n  mobileNumber: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateMessageAnalyticsArgs = {\n  message: Scalars['CakeMessageCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateMessageReactionArgs = {\n  message: Scalars['CakeMessageCakeType']['input'];\n  reaction: Scalars['CleanString']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateNotesOfferPaymentStatusArgs = {\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  notify?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  paid: Scalars['CakeDecimal']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateNotesRoundBankDetailsAuArgs = {\n  accountName?: InputMaybe<Scalars['String']['input']>;\n  isTrustAccount?: InputMaybe<Scalars['Boolean']['input']>;\n  paymentAccount?: InputMaybe<Scalars['String']['input']>;\n  paymentBsb?: InputMaybe<Scalars['String']['input']>;\n  paymentReference?: InputMaybe<Scalars['String']['input']>;\n  round: Scalars['NotesRoundCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateNotesRoundBankDetailsFallbackArgs = {\n  details?: InputMaybe<Scalars['String']['input']>;\n  round: Scalars['NotesRoundCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateNotesRoundBankDetailsSgArgs = {\n  accountName?: InputMaybe<Scalars['String']['input']>;\n  accountNumber?: InputMaybe<Scalars['String']['input']>;\n  bankCode?: InputMaybe<Scalars['String']['input']>;\n  branchCode?: InputMaybe<Scalars['String']['input']>;\n  round: Scalars['NotesRoundCakeType']['input'];\n  swiftCode?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOfferEsopArgs = {\n  offer: Scalars['EsopOfferCakeType']['input'];\n  offerData: EsopOfferInputType;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOfferEssArgs = {\n  offer: Scalars['EssOfferCakeType']['input'];\n  offerData: EssOfferInputType;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOfferRsuArgs = {\n  offer: Scalars['RsuOfferCakeType']['input'];\n  offerData: RsuOfferInputType;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOfferSharePriceEssArgs = {\n  offer: Scalars['EssOfferCakeType']['input'];\n  sharePrice: Scalars['CakeDecimal']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOfferSharePriceFounderVestingArgs = {\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n  sharePrice: Scalars['CakeDecimal']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOfferWarrantArgs = {\n  offer: Scalars['WarrantOfferCakeType']['input'];\n  offerData: WarrantOfferInputType;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOfficeholderArgs = {\n  updateOfficeholderData: UpdateOfficeholderData;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOneTimeAddonStatusArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  status: Scalars['CleanString']['input'];\n  stripeId: Scalars['CleanString']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationAuArgs = {\n  auCompanyDetails: AuCompanyDetailsInput;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationBasicArgs = {\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationCaArgs = {\n  caCompanyDetails: CaCompanyDetailsInput;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationEeArgs = {\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  eeCompanyDetails: EeCompanyDetailsInput;\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationFundingPhaseArgs = {\n  fundingPhase: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationGbArgs = {\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  gbCompanyDetails: GbCompanyDetailsInput;\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationHideUpcomingInvoiceArgs = {\n  hideUpcomingInvoice: Scalars['Boolean']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationInArgs = {\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  inCompanyDetails: InCompanyDetailsInput;\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationNzArgs = {\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  name: Scalars['CleanString']['input'];\n  nzCompanyDetails: NzCompanyDetailsInput;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationSgArgs = {\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  sgCompanyDetails: SgCompanyDetailsInput;\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationUploadInProgressArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  uploadInProgress: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationUsArgs = {\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  name: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n  usCompanyDetails: UsCompanyDetailsInput;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateOrganisationUserRoleArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  position: Scalars['CleanString']['input'];\n  role: Scalars['CleanString']['input'];\n  user: Scalars['UserCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateShareTransferOfferPaymentStatusArgs = {\n  paid: Scalars['CakeDecimal']['input'];\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateShareholderArgs = {\n  shareholder: Scalars['ShareholderCakeType']['input'];\n  shareholderDataInput: ShareholderDataInput;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateSharetypeArgs = {\n  updateSharetypeData: UpdateSharetypeData;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateSignerArgs = {\n  isDeleteOnly: Scalars['Boolean']['input'];\n  isPrimary: Scalars['Boolean']['input'];\n  officeholderId: Scalars['UUID']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateTransactionUnpaidAmountArgs = {\n  tr: Scalars['ShareholdingTransactionCakeType']['input'];\n  unpaidAmount: Scalars['CakeDecimal']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateUserOnboardingArgs = {\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  intents: Array<InputMaybe<Scalars['CleanString']['input']>>;\n  userBackground: Array<InputMaybe<Scalars['CleanString']['input']>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateUserSettingsArgs = {\n  currency: Scalars['CleanString']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpdateVisibilitySettingsArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  ownershipVisibleToOptionholders: Scalars['Boolean']['input'];\n  ownershipVisibleToShareholders: Scalars['Boolean']['input'];\n  valuationVisibleToOptionholders: Scalars['Boolean']['input'];\n  valuationVisibleToShareholders: Scalars['Boolean']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUpgradeSubscriptionArgs = {\n  addons?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;\n  minStakeholders?: InputMaybe<Scalars['PositiveIntegerOrZero']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  stripeCoupon?: InputMaybe<Scalars['CleanString']['input']>;\n  stripePaymentId?: InputMaybe<Scalars['String']['input']>;\n  targetPlanId: Scalars['String']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUploadEditableDocumentArgs = {\n  editableDocument: Scalars['DocumentCakeType']['input'];\n  scanbotDocument: Scalars['ScanbotDocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationUploadToScanbotArgs = {\n  document: Scalars['DocumentCakeType']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationVestCliffOrPeriodicEsopArgs = {\n  offer: Scalars['EsopOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n  vestingValue: Scalars['PositiveIntegerOrZero']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationVestCliffOrPeriodicEssArgs = {\n  offer: Scalars['EssOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n  vestingValue: Scalars['PositiveIntegerOrZero']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationVestCliffOrPeriodicFounderVestingArgs = {\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n  vestingValue: Scalars['PositiveIntegerOrZero']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationVestCliffOrPeriodicRsuArgs = {\n  offer: Scalars['RsuOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n  vestingValue: Scalars['PositiveIntegerOrZero']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationVestCliffOrPeriodicWarrantArgs = {\n  offer: Scalars['WarrantOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n  vestingValue: Scalars['PositiveIntegerOrZero']['input'];\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationVestOfferMilestonesEsopArgs = {\n  milestoneList: Array<InputMaybe<MilestoneVestType>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationVestOfferMilestonesEssArgs = {\n  milestoneList: Array<InputMaybe<MilestoneVestType>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationVestOfferMilestonesFounderVestingArgs = {\n  milestoneList: Array<InputMaybe<MilestoneVestType>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationVestOfferMilestonesRsuArgs = {\n  milestoneList: Array<InputMaybe<MilestoneVestType>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationVestOfferMilestonesWarrantArgs = {\n  milestoneList: Array<InputMaybe<MilestoneVestType>>;\n};\n\n\n/** Defines write functions available in graphQL endpoint. */\nexport type MutationWhitelistUserMfaArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  userId: Scalars['UUID']['input'];\n};\n\nexport type NextVestingEventEntry = {\n  __typename?: 'NextVestingEventEntry';\n  displayName?: Maybe<Scalars['String']['output']>;\n  nextVestingDate?: Maybe<Scalars['Date']['output']>;\n  nextVestingMeta?: Maybe<Scalars['String']['output']>;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n};\n\nexport type NotSignedUpShareholderType = {\n  __typename?: 'NotSignedUpShareholderType';\n  consideredInvited?: Maybe<Scalars['Boolean']['output']>;\n  email?: Maybe<Scalars['String']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  name?: Maybe<Scalars['String']['output']>;\n};\n\nexport type NotSignedUpShareholdersResultType = {\n  __typename?: 'NotSignedUpShareholdersResultType';\n  notSignedUpCount?: Maybe<Scalars['Int']['output']>;\n  results?: Maybe<Array<Maybe<NotSignedUpShareholderType>>>;\n};\n\n/**\n * query { notes\n *     (organisationId: \"00000000-0000-0000-0000-000000000000\") {\n *             id type principal valuation_cap\n *         }\n *     }\n */\nexport type Note = {\n  __typename?: 'Note';\n  /** Miscellaneous information regarding this note that does't fit elsewhere */\n  comment?: Maybe<Scalars['String']['output']>;\n  /** The Note Agreement contract */\n  contract?: Maybe<Document>;\n  created: Scalars['DateTime']['output'];\n  discountRate?: Maybe<Scalars['CakeDecimal']['output']>;\n  id: Scalars['UUID']['output'];\n  /** Frequency for interest accrual, in months */\n  interestAccrualFrequency?: Maybe<Scalars['Int']['output']>;\n  /** How the note got resolved once it is no longer active */\n  interestAccrualMethod?: Maybe<NotesNoteInterestAccrualMethodChoices>;\n  interestRate?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Date of note issuance. */\n  issueDate: Scalars['Date']['output'];\n  /** Final date for conversion. In case of SAFE notes, leave null. */\n  maturityDate?: Maybe<Scalars['Date']['output']>;\n  modified: Scalars['DateTime']['output'];\n  notesroundoffer?: Maybe<NotesRoundOfferType>;\n  /** Affected note */\n  notetransactionSet: Array<NoteTransaction>;\n  /** Organisation this Note belongs to */\n  organisation: Organisation;\n  principal?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** How the note got resolved once it is no longer active */\n  resolution?: Maybe<NotesNoteResolutionChoices>;\n  resolutionDate?: Maybe<Scalars['Date']['output']>;\n  shareType?: Maybe<Sharetype>;\n  /** Noteholder */\n  shareholder: Shareholder;\n  transactions?: Maybe<Array<Maybe<NoteTransaction>>>;\n  /** Type of convertible debt */\n  type: NotesNoteTypeChoices;\n  valuationCap?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\n/** An enumeration. */\nexport enum NoteConversionEnum {\n  Automatic = 'AUTOMATIC',\n  Manual = 'MANUAL',\n  NoConversion = 'NO_CONVERSION'\n}\n\nexport type NoteConversionSimulationInputType = {\n  convertOnRound: Scalars['Int']['input'];\n  discountRate: Scalars['Float']['input'];\n  investorName: Scalars['String']['input'];\n  principalIncludingInterest: Scalars['Float']['input'];\n  valuationCap: Scalars['Float']['input'];\n};\n\nexport type NoteConversionSimulationOutputType = {\n  __typename?: 'NoteConversionSimulationOutputType';\n  convertOnRound: Scalars['Int']['output'];\n  discountRate: Scalars['Float']['output'];\n  investorName: Scalars['String']['output'];\n  principalIncludingInterest: Scalars['Float']['output'];\n  valuationCap: Scalars['Float']['output'];\n};\n\nexport type NoteTransaction = {\n  __typename?: 'NoteTransaction';\n  created: Scalars['DateTime']['output'];\n  /** Internal identifier for coherence between TRANSFER_IN and TRANSFER_OUT */\n  group?: Maybe<Scalars['UUID']['output']>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** Affected note */\n  note: Note;\n  /** Transaction of note conversion shares issuance */\n  shareTransaction?: Maybe<ShareholdingTransaction>;\n  /** Noteholder subject to this transaction */\n  shareholder: Shareholder;\n  /** Date of transaction event */\n  transactionDate: Scalars['Date']['output'];\n  /** Type of transaction affecting note */\n  type: NotesNoteTransactionTypeChoices;\n};\n\n/** An enumeration. */\nexport enum NoteType {\n  Convertible = 'CONVERTIBLE',\n  Custom = 'CUSTOM',\n  Safe = 'SAFE'\n}\n\n/** An enumeration. */\nexport enum NotesNoteInterestAccrualMethodChoices {\n  /** Interest compounds over time */\n  Compounding = 'COMPOUNDING',\n  /** Interest is always calculated on principal */\n  Simple = 'SIMPLE'\n}\n\n/** An enumeration. */\nexport enum NotesNoteResolutionChoices {\n  /** Note has been cancelled */\n  Cancelled = 'CANCELLED',\n  /** Note has been converted into shares */\n  Converted = 'CONVERTED',\n  /** Note has been dissolved */\n  Dissolved = 'DISSOLVED',\n  /** Note has been repaid */\n  Paid = 'PAID'\n}\n\n/** An enumeration. */\nexport enum NotesNoteTransactionTypeChoices {\n  /** Note has been cancelled */\n  Cancel = 'CANCEL',\n  /** Note has been converted into shares */\n  Convert = 'CONVERT',\n  /** Note has been dissolved */\n  Dissolve = 'DISSOLVE',\n  /** Note has been issued */\n  Issue = 'ISSUE',\n  /** Note has been repaid */\n  Repay = 'REPAY'\n}\n\n/** An enumeration. */\nexport enum NotesNoteTypeChoices {\n  /** Convertible Note */\n  Convertible = 'CONVERTIBLE',\n  /** Note with non-standard terms */\n  Custom = 'CUSTOM',\n  /** Simple Agreement for Future Equity */\n  Safe = 'SAFE'\n}\n\nexport type NotesRoundOfferType = {\n  __typename?: 'NotesRoundOfferType';\n  /** The Note Agreement associated with this offer */\n  contract?: Maybe<Document>;\n  /** The Note Agreement template associated with this offer */\n  contractTemplate?: Maybe<Document>;\n  created: Scalars['DateTime']['output'];\n  /** Discount over valuation-based share price */\n  discountRate?: Maybe<Scalars['Decimal']['output']>;\n  id: Scalars['UUID']['output'];\n  /** Frequency for interest accrual, in months */\n  interestAccrualFrequency?: Maybe<Scalars['Int']['output']>;\n  /** How the note got resolved once it is no longer active */\n  interestAccrualMethod?: Maybe<NotesroundsNotesRoundOfferInterestAccrualMethodChoices>;\n  /** Interest rate to be accrued. In case of SAFE notes, leave null. */\n  interestRate?: Maybe<Scalars['Decimal']['output']>;\n  /** Final date for conversion. In case of SAFE notes, leave null. */\n  maturityDate?: Maybe<Scalars['Date']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** The Note issued from this offer */\n  note?: Maybe<Note>;\n  noteType?: Maybe<NoteType>;\n  /** Notes Round that this offer is part of */\n  notesRound: NotesRoundType;\n  owing?: Maybe<Scalars['CakeDecimal']['output']>;\n  paid?: Maybe<Scalars['CakeDecimal']['output']>;\n  payment?: Maybe<PaymentDetailsField>;\n  /** Bank Details */\n  paymentDetails?: Maybe<Scalars['JSONString']['output']>;\n  principal?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Makes it a requirement that a witness also needs to sign the offer note. */\n  requireWitness: Scalars['Boolean']['output'];\n  shareType?: Maybe<Sharetype>;\n  /** Future Noteholder */\n  shareholder: Shareholder;\n  /** Retains the last known status for this offer */\n  status: NotesroundsNotesRoundOfferStatusChoices;\n  /** Maximum valuation to be considered for share price calculations */\n  valuationCap?: Maybe<Scalars['Decimal']['output']>;\n};\n\nexport type NotesRoundType = {\n  __typename?: 'NotesRoundType';\n  accountName?: Maybe<Scalars['String']['output']>;\n  amountPaid?: Maybe<Scalars['CakeDecimal']['output']>;\n  amountRaised?: Maybe<Scalars['CakeDecimal']['output']>;\n  cakegroupSet: Array<CakeGroupType>;\n  capitalRaisingEventAmount?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** The Note Agreement template to use in offers */\n  contractTemplate?: Maybe<Document>;\n  created: Scalars['DateTime']['output'];\n  discountRate?: Maybe<Scalars['CakeDecimal']['output']>;\n  documents?: Maybe<Array<Maybe<Document>>>;\n  /** Conclusion date for round */\n  endDate?: Maybe<Scalars['Date']['output']>;\n  id: Scalars['UUID']['output'];\n  /** Frequency for interest accrual, in months */\n  interestAccrualFrequency?: Maybe<Scalars['Int']['output']>;\n  /** How the note got resolved once it is no longer active */\n  interestAccrualMethod?: Maybe<NotesroundsNotesRoundInterestAccrualMethodChoices>;\n  interestRate?: Maybe<Scalars['CakeDecimal']['output']>;\n  isTrustAccount?: Maybe<Scalars['Boolean']['output']>;\n  /** Final date for conversion. In case of SAFE notes, leave null. */\n  maturityDate?: Maybe<Scalars['Date']['output']>;\n  maxInvestmentAmount?: Maybe<Scalars['CakeDecimal']['output']>;\n  minInvestmentAmount?: Maybe<Scalars['CakeDecimal']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** Name of Notes Round */\n  name: Scalars['String']['output'];\n  /** Type of convertible debt */\n  noteType: NotesroundsNotesRoundNoteTypeChoices;\n  /** Notes Round that this offer is part of */\n  notesroundofferSet: Array<NotesRoundOfferType>;\n  offerCount?: Maybe<Scalars['Int']['output']>;\n  /** Organisation this Notes Round belongs to */\n  organisation: Organisation;\n  payment?: Maybe<PaymentDetailsField>;\n  paymentAccount?: Maybe<Scalars['String']['output']>;\n  paymentBsb?: Maybe<Scalars['String']['output']>;\n  /** Bank Details */\n  paymentDetails?: Maybe<Scalars['JSONString']['output']>;\n  paymentReference?: Maybe<Scalars['String']['output']>;\n  roundInvestmentGoal?: Maybe<Scalars['CakeDecimal']['output']>;\n  shareType?: Maybe<Sharetype>;\n  valuationCap?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\n/** An enumeration. */\nexport enum NotesroundsNotesRoundInterestAccrualMethodChoices {\n  /** Interest compounds over time */\n  Compounding = 'COMPOUNDING',\n  /** Interest is always calculated on principal */\n  Simple = 'SIMPLE'\n}\n\n/** An enumeration. */\nexport enum NotesroundsNotesRoundNoteTypeChoices {\n  /** Convertible Note */\n  Convertible = 'CONVERTIBLE',\n  /** Note with non-standard terms */\n  Custom = 'CUSTOM',\n  /** Simple Agreement for Future Equity */\n  Safe = 'SAFE'\n}\n\n/** An enumeration. */\nexport enum NotesroundsNotesRoundOfferInterestAccrualMethodChoices {\n  /** Interest compounds over time */\n  Compounding = 'COMPOUNDING',\n  /** Interest is always calculated on principal */\n  Simple = 'SIMPLE'\n}\n\n/** An enumeration. */\nexport enum NotesroundsNotesRoundOfferStatusChoices {\n  /** Investor refused the offer */\n  Declined = 'DECLINED',\n  /** Offer concluded */\n  NoteIssued = 'NOTE_ISSUED',\n  /** Waiting for Investor to accept and confirm investment amount */\n  ReadyToAccept = 'READY_TO_ACCEPT',\n  /** Waiting for Investor to confirm Details */\n  ReadyToConfirmDetails = 'READY_TO_CONFIRM_DETAILS',\n  /** Waiting for Officeholder to Issue Note */\n  ReadyToIssue = 'READY_TO_ISSUE',\n  /** Waiting for Investor to pay */\n  ReadyToPay = 'READY_TO_PAY',\n  /** Waiting for Investor Signatures */\n  ReadyToSign = 'READY_TO_SIGN',\n  /** Waiting for Officeholder to send Invitation */\n  ReadyToStart = 'READY_TO_START'\n}\n\nexport type NzCompanyDetailsField = {\n  __typename?: 'NzCompanyDetailsField';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  nzbn?: Maybe<Scalars['String']['output']>;\n  organisation: Organisation;\n  registeredAddress?: Maybe<InternationalAddressField>;\n  registeredAgentEmail?: Maybe<Scalars['String']['output']>;\n  registeredAgentName?: Maybe<Scalars['String']['output']>;\n};\n\nexport type NzCompanyDetailsInput = {\n  nzbn: Scalars['CleanString']['input'];\n  registeredAddress?: InputMaybe<AddressInput>;\n  registeredAgentEmail?: InputMaybe<Scalars['String']['input']>;\n  registeredAgentName?: InputMaybe<Scalars['String']['input']>;\n};\n\nexport type OffboardEventSettingsInputType = {\n  accelerateAmount?: InputMaybe<Scalars['PositiveIntegerOrZero']['input']>;\n  fullyLapse: Scalars['Boolean']['input'];\n  repurchaseValueUnvested?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  repurchaseValueVested?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  stopVestingAt: SeOffboardEventSettingsStopVestingAtChoices;\n};\n\nexport type OffboardEventSettingsOutputType = {\n  __typename?: 'OffboardEventSettingsOutputType';\n  accelerateAmount: Scalars['Int']['output'];\n  /** Whether vestable lapse on offboarding */\n  autoLapse: Scalars['Boolean']['output'];\n  complete: Scalars['Boolean']['output'];\n  created: Scalars['DateTime']['output'];\n  esopoffer?: Maybe<EsopOffer>;\n  essoffer?: Maybe<EssOffer>;\n  foundervestingoffer?: Maybe<FounderVestingOfferOutputType>;\n  fullyLapse: Scalars['Boolean']['output'];\n  id: Scalars['UUID']['output'];\n  /** Date when the reminder to lapse vestable was sent. If there is no date, no reminder was sent. */\n  lapseReminderDate?: Maybe<Scalars['DateTime']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** Whether to notify the employee on auto lapse */\n  notifyOnAutoLapse: Scalars['Boolean']['output'];\n  offboarding: OffboardingOutputType;\n  /** Amount to buyback unvested vestable */\n  repurchaseValueUnvested?: Maybe<Scalars['Decimal']['output']>;\n  /** Amount to buyback vested vestable */\n  repurchaseValueVested?: Maybe<Scalars['Decimal']['output']>;\n  rsuoffer?: Maybe<RsuOfferOutputType>;\n  stopVestingAt: SeOffboardEventSettingsStopVestingAtChoices;\n  warrantoffer?: Maybe<WarrantOfferOutputType>;\n};\n\nexport type OffboardPtepDataInputType = {\n  autoLapseUnexercised: Scalars['Boolean']['input'];\n  postTerminationExercisePeriod: TimeSliceInputType;\n  sendExerciseReminder: Scalars['Boolean']['input'];\n};\n\nexport type OffboardingEntryInputType = {\n  id: Scalars['UUID']['input'];\n  ptep?: InputMaybe<OffboardPtepDataInputType>;\n  settings: OffboardEventSettingsInputType;\n  type: OffboardingModelTypeEnum;\n};\n\nexport enum OffboardingModelTypeEnum {\n  Esop = 'ESOP',\n  Ess = 'ESS',\n  Foundervesting = 'FOUNDERVESTING',\n  Rsu = 'RSU'\n}\n\nexport type OffboardingOutputType = {\n  __typename?: 'OffboardingOutputType';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  offboardeventsettingsSet?: Maybe<Array<Maybe<OffboardEventSettingsOutputType>>>;\n  shareholder: Shareholder;\n  status: OffboardingStatus;\n  terminationDate: Scalars['Date']['output'];\n  terminator?: Maybe<UserType>;\n};\n\n/** An enumeration. */\nexport enum OffboardingStatus {\n  Completed = 'COMPLETED',\n  Scheduled = 'SCHEDULED',\n  Waiting = 'WAITING'\n}\n\nexport type OfferCalendarOutputType = {\n  __typename?: 'OfferCalendarOutputType';\n  count?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  entries?: Maybe<Array<VestingCalendarOutputEntry>>;\n  vestStartDate?: Maybe<Scalars['Date']['output']>;\n};\n\nexport type OfferExerciseExpirationDataInputType = {\n  autoLapseOnExpirationDate: Scalars['Boolean']['input'];\n  expireDate?: InputMaybe<Scalars['Date']['input']>;\n  expireTime?: InputMaybe<TimeSliceInputType>;\n  sendExpirationNotification: Scalars['Boolean']['input'];\n  startingPoint?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\nexport type OfferInputType = {\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  conversionLockEvent?: InputMaybe<Scalars['CleanString']['input']>;\n  emailsOn?: InputMaybe<Scalars['Boolean']['input']>;\n  grantDate?: InputMaybe<Scalars['Date']['input']>;\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n  vestingEvents: Array<InputMaybe<VestingEventInputType>>;\n};\n\n/**\n *\n *     # The profile for an Officeholder\n *     # Queries the list of Officeholder for a given organisationId.\n *\n *     query Example {officeholders\n *         (organisationId: \"604ad5d1-c44f-44b2-abb4-7877d96ed188\") {\n *                 id\n *                 name\n *             }\n *         }\n *\n */\nexport type Officeholder = {\n  __typename?: 'Officeholder';\n  avatar?: Maybe<Scalars['String']['output']>;\n  cakegroupSet: Array<CakeGroupType>;\n  created: Scalars['DateTime']['output'];\n  email?: Maybe<Scalars['String']['output']>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  name: Scalars['String']['output'];\n  organisation: Organisation;\n  roles: Array<OfficeholderRoleType>;\n  signature?: Maybe<Scalars['String']['output']>;\n  /** Whether this officeholder has signing priviledges, and which */\n  signer?: Maybe<SeOfficeholderSignerChoices>;\n  user?: Maybe<UserType>;\n};\n\nexport type OfficeholderInput = {\n  email: Scalars['CleanString']['input'];\n  forceUpdateSigner?: InputMaybe<Scalars['Boolean']['input']>;\n  name: Scalars['CleanString']['input'];\n  permission?: InputMaybe<Scalars['String']['input']>;\n  roles: Array<InputMaybe<OfficeholderRoleInputType>>;\n  signer?: InputMaybe<Scalars['String']['input']>;\n};\n\nexport type OfficeholderRoleInputType = {\n  role: Scalars['String']['input'];\n};\n\nexport type OfficeholderRoleType = {\n  __typename?: 'OfficeholderRoleType';\n  id: Scalars['UUID']['output'];\n  name?: Maybe<Scalars['String']['output']>;\n  officeholder: Officeholder;\n  role: SeOfficeholderRoleRoleChoices;\n};\n\nexport type OneOffAddon = {\n  __typename?: 'OneOffAddon';\n  addonType?: Maybe<AddonType>;\n  created?: Maybe<Scalars['Date']['output']>;\n  status?: Maybe<Scalars['CleanString']['output']>;\n  stripeId?: Maybe<Scalars['CleanString']['output']>;\n};\n\nexport type OptionExerciseRequestSettingsType = {\n  __typename?: 'OptionExerciseRequestSettingsType';\n  approvers?: Maybe<Array<Maybe<UserType>>>;\n  /** Whether or not an ESOP offer holder can request exercise */\n  canRequestExercise: Scalars['Boolean']['output'];\n  created: Scalars['DateTime']['output'];\n  /** Exercise Notice template for option exercise requests */\n  exerciseNoticeTemplate: Document;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** Organisation */\n  organisation: Organisation;\n  paymentDetails?: Maybe<PaymentDetailsOutputType>;\n};\n\nexport type OptionExerciseRequestType = {\n  __typename?: 'OptionExerciseRequestType';\n  created: Scalars['DateTime']['output'];\n  /** Date by which the approvers must make a decision */\n  decisionDate?: Maybe<Scalars['Date']['output']>;\n  /** Exercise notice for this request */\n  exerciseNotice?: Maybe<Document>;\n  exerciseTransaction?: Maybe<EsopTransaction>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  offer?: Maybe<EsopOffer>;\n  recipientReference?: Maybe<Scalars['String']['output']>;\n  shareCertificateId?: Maybe<Scalars['UUID']['output']>;\n  /** Status of the exercise request */\n  status: EsopOptionExerciseRequestStatusChoices;\n  taxWithholding?: Maybe<Scalars['CakeDecimal']['output']>;\n  trustee?: Maybe<Shareholder>;\n  /** Number of options the investor/employee wants to exercise */\n  vestingValue: Scalars['BigInt']['output'];\n};\n\nexport type OrgData = {\n  __typename?: 'OrgData';\n  currency?: Maybe<Scalars['String']['output']>;\n  fullyDiluted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  logo?: Maybe<Scalars['String']['output']>;\n  name?: Maybe<Scalars['String']['output']>;\n  valuation?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\n/**\n *\n *     # The Organisation with a project. To Query list\n *     # of organisations a user is an officeholder of.\n *\n *     query Example1 { organisations }\n *\n *     # To query attributes of a specific organisation by Id.\n *\n *     query Example2 {\n *         organisation(\n *             organisationId: \"86318182-005b-427a-a3af-be07230a5e58\"\n *         ){\n *             id\n *             name\n *             acnAbn\n *             userRoles\n *         }\n *     }\n *\n *\n */\nexport type Organisation = {\n  __typename?: 'Organisation';\n  activeInvestors?: Maybe<Array<Maybe<Shareholder>>>;\n  /** The annual revenue of the company */\n  annualRevenue?: Maybe<Scalars['String']['output']>;\n  aucompanydetails?: Maybe<AuCompanyDetailsField>;\n  /** Date when auto-upgrades resume. If null, organisation participates normally. If set to a future date, upgrades are paused until the day before this date. Use a far-future date for indefinite exclusion. */\n  autoUpgradeResumeDate?: Maybe<Scalars['Date']['output']>;\n  boardapprovalSet: Array<BoardApprovalType>;\n  cacompanydetails?: Maybe<CaCompanyDetailsField>;\n  cakereplythreadSet: Array<CakeReplyThreadType>;\n  commentSet: Array<CommentType>;\n  companyDetails?: Maybe<CompanyDetailsField>;\n  /** The amount of employees in the company */\n  companySize?: Maybe<OrganisationsOrganisationCompanySizeChoices>;\n  /** The type of organisation selected in the setup company */\n  companyType?: Maybe<OrganisationsOrganisationCompanyTypeChoices>;\n  contactInfo?: Maybe<Scalars['JSONString']['output']>;\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  createdBy: UserType;\n  /** The product intent selected in the setup company */\n  creationIntent?: Maybe<OrganisationsOrganisationCreationIntentChoices>;\n  /** Select multiple product intents in setup company */\n  creationIntents: Array<Scalars['String']['output']>;\n  /** The role of the creator of the organisation */\n  creatorRole?: Maybe<OrganisationsOrganisationCreatorRoleChoices>;\n  /** Currency code according to ISO 4217 */\n  currency: OrganisationsOrganisationCurrencyChoices;\n  eecompanydetails?: Maybe<EeCompanyDetailsField>;\n  /** Organisation that the saved model belongs to */\n  equitymodelSet: Array<EquityModelOutputType>;\n  /** How experienced the user is with cap tables */\n  experienceLevel?: Maybe<OrganisationsOrganisationExperienceLevelChoices>;\n  /** Organisation this plan belongs to */\n  foundervestingSet: Array<FounderVestingOutputType>;\n  fullyDilutedShares?: Maybe<Scalars['BigInt']['output']>;\n  fundingPhase?: Maybe<Scalars['String']['output']>;\n  fundingPhaseLastUpdated?: Maybe<Scalars['Date']['output']>;\n  gbcompanydetails?: Maybe<GbCompanyDetailsField>;\n  hasConNotes?: Maybe<Scalars['Boolean']['output']>;\n  hasEsopPlans?: Maybe<Scalars['Boolean']['output']>;\n  hasEssPlans?: Maybe<Scalars['Boolean']['output']>;\n  hasFounderVestingPlans?: Maybe<Scalars['Boolean']['output']>;\n  hasGrantedEsopOffers?: Maybe<Scalars['Boolean']['output']>;\n  hasRsuPlans?: Maybe<Scalars['Boolean']['output']>;\n  hasSafeNotes?: Maybe<Scalars['Boolean']['output']>;\n  hasValuation?: Maybe<Scalars['Boolean']['output']>;\n  hasWarrantPlans?: Maybe<Scalars['Boolean']['output']>;\n  /** Hide upcoming invoice in the billing section */\n  hideUpcomingInvoice: Scalars['Boolean']['output'];\n  historical409aSet: Array<Historical409AType>;\n  id: Scalars['UUID']['output'];\n  incompanydetails?: Maybe<InCompanyDetailsField>;\n  /** If a company has shown interest in having a 409A during creation */\n  interestedIn409a?: Maybe<Scalars['Boolean']['output']>;\n  isTrust: Scalars['Boolean']['output'];\n  lastCertificateNumber?: Maybe<Scalars['Int']['output']>;\n  license?: Maybe<LicenseInfoType>;\n  logo: Scalars['String']['output'];\n  /** Logo image */\n  logoImage?: Maybe<Scalars['String']['output']>;\n  logoImageLink?: Maybe<Scalars['String']['output']>;\n  mfaRequired?: Maybe<Scalars['Boolean']['output']>;\n  modified: Scalars['DateTime']['output'];\n  name: Scalars['String']['output'];\n  /** Organisation this Note belongs to */\n  noteSet: Array<Note>;\n  nzcompanydetails?: Maybe<NzCompanyDetailsField>;\n  officeholderSet: Array<Officeholder>;\n  optionexerciserequestsettings?: Maybe<OptionExerciseRequestSettingsType>;\n  ownershipVisibleToOptionholders?: Maybe<Scalars['Boolean']['output']>;\n  ownershipVisibleToShareholders?: Maybe<Scalars['Boolean']['output']>;\n  partner?: Maybe<CakePartner>;\n  /** Reason for onboarding */\n  reasonForOnboarding?: Maybe<Scalars['String']['output']>;\n  /** Organisation this plan belongs to */\n  rsuSet: Array<RsuOutputType>;\n  /** If set, the date when the organisation is scheduled for deletion */\n  scheduledForDeletion?: Maybe<Scalars['DateTime']['output']>;\n  /** The date and time when the scheduled for deletion email was sent */\n  scheduledForDeletionEmailSent?: Maybe<Scalars['DateTime']['output']>;\n  sgcompanydetails?: Maybe<SgCompanyDetailsField>;\n  /** The type of share certificate to be generated */\n  shareCertificateType: OrganisationsOrganisationShareCertificateTypeChoices;\n  sharecertificatedisclaimerSet: Array<ShareCertificateDisclaimerType>;\n  sharetypeSet: Array<Sharetype>;\n  /** Whether onboarding flow still needs to be presented */\n  showOnboarding: Scalars['Boolean']['output'];\n  /** Source of referral */\n  sourceOfReferral?: Maybe<Scalars['String']['output']>;\n  /** Stripe customer id */\n  stripeCustomerId?: Maybe<Scalars['String']['output']>;\n  totalSecurities?: Maybe<Scalars['BigInt']['output']>;\n  totalShares?: Maybe<Scalars['BigInt']['output']>;\n  totalSharesUnexercised?: Maybe<Scalars['BigInt']['output']>;\n  type?: Maybe<Scalars['String']['output']>;\n  /** If a CS upload is in progress for this company */\n  uploadInProgress: Scalars['Boolean']['output'];\n  uscompanydetails?: Maybe<UsCompanyDetailsField>;\n  userRoles?: Maybe<Array<Maybe<OrganisationUserRoleType>>>;\n  usersWithAggregatedRoles?: Maybe<Array<Maybe<UserWithAggregatedRoles>>>;\n  valuationAt?: Maybe<ValuationType>;\n  /** Date of the last valuation request */\n  valuationRequestDate?: Maybe<Scalars['Date']['output']>;\n  /** Retains the last known status for this valuation request */\n  valuationRequestStatus?: Maybe<OrganisationsOrganisationValuationRequestStatusChoices>;\n  valuationVisibleToOptionholders?: Maybe<Scalars['Boolean']['output']>;\n  valuationVisibleToShareholders?: Maybe<Scalars['Boolean']['output']>;\n  valuations?: Maybe<Array<Maybe<ValuationType>>>;\n  /** Organisation */\n  vestingscheduletemplateSet: Array<VestingScheduleTemplateType>;\n  /** Organisation this plan belongs to */\n  warrantSet: Array<WarrantOutputType>;\n};\n\n\n/**\n *\n *     # The Organisation with a project. To Query list\n *     # of organisations a user is an officeholder of.\n *\n *     query Example1 { organisations }\n *\n *     # To query attributes of a specific organisation by Id.\n *\n *     query Example2 {\n *         organisation(\n *             organisationId: \"86318182-005b-427a-a3af-be07230a5e58\"\n *         ){\n *             id\n *             name\n *             acnAbn\n *             userRoles\n *         }\n *     }\n *\n *\n */\nexport type OrganisationValuationAtArgs = {\n  date?: InputMaybe<Scalars['Date']['input']>;\n};\n\nexport type OrganisationPreDeletionReportType = {\n  __typename?: 'OrganisationPreDeletionReportType';\n  creationDate?: Maybe<Scalars['Date']['output']>;\n  dateOfCurrentSubscription?: Maybe<Scalars['Date']['output']>;\n  hasCancelled?: Maybe<Scalars['Boolean']['output']>;\n  hasPausedBefore?: Maybe<Scalars['Boolean']['output']>;\n  isPaused?: Maybe<Scalars['Boolean']['output']>;\n  numberOfFiles?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  numberOfFounderAppUsers?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  numberOfOffers?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  numberOfStakeholders?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  stakeholdersInCake?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type OrganisationRaise = {\n  __typename?: 'OrganisationRaise';\n  accountName?: Maybe<Scalars['String']['output']>;\n  amountPaid?: Maybe<Scalars['CakeDecimal']['output']>;\n  amountRaised?: Maybe<Scalars['CakeDecimal']['output']>;\n  cakegroupSet: Array<CakeGroupType>;\n  companyOffered?: Maybe<Scalars['CakeDecimal']['output']>;\n  contractTemplate?: Maybe<Document>;\n  created: Scalars['DateTime']['output'];\n  documents?: Maybe<Array<Maybe<Document>>>;\n  endDate?: Maybe<Scalars['Date']['output']>;\n  existingShares?: Maybe<Scalars['BigInt']['output']>;\n  id: Scalars['UUID']['output'];\n  isTrustAccount?: Maybe<Scalars['Boolean']['output']>;\n  maxInvestAmount?: Maybe<Scalars['CakeDecimal']['output']>;\n  minInvestAmount?: Maybe<Scalars['CakeDecimal']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** Raise name, eg. Seed Round */\n  name?: Maybe<Scalars['String']['output']>;\n  offerCount?: Maybe<Scalars['Int']['output']>;\n  organisation: Organisation;\n  /** Equity Raise that this offer is part of */\n  organisationraiseofferSet: Array<OrganisationRaiseOffer>;\n  payment?: Maybe<PaymentDetailsField>;\n  paymentAccount?: Maybe<Scalars['String']['output']>;\n  paymentBsb?: Maybe<Scalars['String']['output']>;\n  paymentReference?: Maybe<Scalars['String']['output']>;\n  raiseGoalAmount?: Maybe<Scalars['CakeDecimal']['output']>;\n  shareType: Sharetype;\n  valuation?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type OrganisationRaiseOffer = {\n  __typename?: 'OrganisationRaiseOffer';\n  amount?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** The certificate guarateeing this offer's issuance */\n  certificate?: Maybe<Document>;\n  /** The Agreement associated with this offer */\n  contract?: Maybe<Document>;\n  created: Scalars['DateTime']['output'];\n  expectedShares?: Maybe<Scalars['Float']['output']>;\n  id: Scalars['UUID']['output'];\n  inviteDate?: Maybe<Scalars['Date']['output']>;\n  /** The transaction guaranteeing this offer's issuance */\n  issueTransaction?: Maybe<ShareholdingTransaction>;\n  modified: Scalars['DateTime']['output'];\n  /** Equity Raise that this offer is part of */\n  organisationRaise: OrganisationRaise;\n  owing?: Maybe<Scalars['CakeDecimal']['output']>;\n  paid?: Maybe<Scalars['CakeDecimal']['output']>;\n  reminderSentDate?: Maybe<Scalars['Date']['output']>;\n  /** Makes it a requirement that a witness also needs to sign the subscription agreement. */\n  requireWitness: Scalars['Boolean']['output'];\n  /** Potential Investor */\n  shareholder: Shareholder;\n  shareholdingTransaction?: Maybe<ShareholdingTransaction>;\n  /** Retains the last known status for this offer */\n  status: SeOrganisationRaiseOfferStatusChoices;\n};\n\nexport type OrganisationUserRolePositionType = {\n  __typename?: 'OrganisationUserRolePositionType';\n  position?: Maybe<Scalars['String']['output']>;\n  role?: Maybe<Scalars['String']['output']>;\n};\n\nexport type OrganisationUserRoleType = {\n  __typename?: 'OrganisationUserRoleType';\n  created: Scalars['DateTime']['output'];\n  expire?: Maybe<Scalars['String']['output']>;\n  id: Scalars['UUID']['output'];\n  mask?: Maybe<Scalars['Int']['output']>;\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  position?: Maybe<OrganisationsOrganisationUserRolePositionChoices>;\n  role: OrganisationsOrganisationUserRoleRoleChoices;\n  user: UserType;\n};\n\n/** An enumeration. */\nexport enum OrganisationsOrganisationCompanySizeChoices {\n  /** 1-5 */\n  A_1_5 = 'A_1_5',\n  /** 6-10 */\n  A_6_10 = 'A_6_10',\n  /** 11-20 */\n  A_11_20 = 'A_11_20',\n  /** 21-50 */\n  A_21_50 = 'A_21_50',\n  /** 51-100 */\n  A_51_100 = 'A_51_100',\n  /** 100+ */\n  A_100 = 'A_100_'\n}\n\n/** An enumeration. */\nexport enum OrganisationsOrganisationCompanyTypeChoices {\n  /** C-CORP */\n  CCorp = 'C_CORP',\n  /** INCORPORATION */\n  Incorporation = 'INCORPORATION',\n  /** LLC */\n  Llc = 'LLC',\n  /** LLP */\n  Llp = 'LLP',\n  /** NON-PROFIT */\n  NonProfit = 'NON_PROFIT',\n  /** SOLE-PROPRIETORSHIP */\n  SoleProprietorship = 'SOLE_PROPRIETORSHIP',\n  /** S-CORP */\n  SCorp = 'S_CORP'\n}\n\n/** An enumeration. */\nexport enum OrganisationsOrganisationCreationIntentChoices {\n  /** CAPTABLE */\n  Captable = 'CAPTABLE',\n  /** CONVERTIBLE */\n  Convertible = 'CONVERTIBLE',\n  /** NONE */\n  None = 'NONE',\n  /** PLANS */\n  Plans = 'PLANS',\n  /** SAFE */\n  Safe = 'SAFE'\n}\n\n/** An enumeration. */\nexport enum OrganisationsOrganisationCreatorRoleChoices {\n  /** EXECUTIVE */\n  Executive = 'EXECUTIVE',\n  /** FIRST-TIME-FOUNDER */\n  FirstTimeFounder = 'FIRST_TIME_FOUNDER',\n  /** REPEAT-FOUNDER */\n  RepeatFounder = 'REPEAT_FOUNDER',\n  /** SERVICE-PROVIDER */\n  ServiceProvider = 'SERVICE_PROVIDER'\n}\n\n/** An enumeration. */\nexport enum OrganisationsOrganisationCurrencyChoices {\n  /** UAE Dirham */\n  Aed = 'AED',\n  /** Afghani */\n  Afn = 'AFN',\n  /** Lek */\n  All = 'ALL',\n  /** Armenian Dram */\n  Amd = 'AMD',\n  /** Netherlands Antillean Guilder */\n  Ang = 'ANG',\n  /** Kwanza */\n  Aoa = 'AOA',\n  /** Argentine Peso */\n  Ars = 'ARS',\n  /** Australian Dollar */\n  Aud = 'AUD',\n  /** Aruban Florin */\n  Awg = 'AWG',\n  /** Azerbaijan Manat */\n  Azn = 'AZN',\n  /** Convertible Mark */\n  Bam = 'BAM',\n  /** Barbados Dollar */\n  Bbd = 'BBD',\n  /** Taka */\n  Bdt = 'BDT',\n  /** Bulgarian Lev */\n  Bgn = 'BGN',\n  /** Bahraini Dinar */\n  Bhd = 'BHD',\n  /** Burundi Franc */\n  Bif = 'BIF',\n  /** Bermudian Dollar */\n  Bmd = 'BMD',\n  /** Brunei Dollar */\n  Bnd = 'BND',\n  /** Boliviano */\n  Bob = 'BOB',\n  /** Mvdol */\n  Bov = 'BOV',\n  /** Brazilian Real */\n  Brl = 'BRL',\n  /** Bahamian Dollar */\n  Bsd = 'BSD',\n  /** Ngultrum */\n  Btn = 'BTN',\n  /** Pula */\n  Bwp = 'BWP',\n  /** Belarusian Ruble */\n  Byn = 'BYN',\n  /** Belize Dollar */\n  Bzd = 'BZD',\n  /** Canadian Dollar */\n  Cad = 'CAD',\n  /** Congolese Franc */\n  Cdf = 'CDF',\n  /** WIR Euro */\n  Che = 'CHE',\n  /** Swiss Franc */\n  Chf = 'CHF',\n  /** WIR Franc */\n  Chw = 'CHW',\n  /** Unidad de Fomento */\n  Clf = 'CLF',\n  /** Chilean Peso */\n  Clp = 'CLP',\n  /** Yuan Renminbi */\n  Cny = 'CNY',\n  /** Colombian Peso */\n  Cop = 'COP',\n  /** Unidad de Valor Real */\n  Cou = 'COU',\n  /** Costa Rican Colon */\n  Crc = 'CRC',\n  /** Peso Convertible */\n  Cuc = 'CUC',\n  /** Cuban Peso */\n  Cup = 'CUP',\n  /** Cabo Verde Escudo */\n  Cve = 'CVE',\n  /** Czech Koruna */\n  Czk = 'CZK',\n  /** Djibouti Franc */\n  Djf = 'DJF',\n  /** Danish Krone */\n  Dkk = 'DKK',\n  /** Dominican Peso */\n  Dop = 'DOP',\n  /** Algerian Dinar */\n  Dzd = 'DZD',\n  /** Egyptian Pound */\n  Egp = 'EGP',\n  /** Nakfa */\n  Ern = 'ERN',\n  /** Ethiopian Birr */\n  Etb = 'ETB',\n  /** Euro */\n  Eur = 'EUR',\n  /** Fiji Dollar */\n  Fjd = 'FJD',\n  /** Falkland Islands Pound */\n  Fkp = 'FKP',\n  /** Pound Sterling */\n  Gbp = 'GBP',\n  /** Lari */\n  Gel = 'GEL',\n  /** Ghana Cedi */\n  Ghs = 'GHS',\n  /** Gibraltar Pound */\n  Gip = 'GIP',\n  /** Dalasi */\n  Gmd = 'GMD',\n  /** Guinean Franc */\n  Gnf = 'GNF',\n  /** Quetzal */\n  Gtq = 'GTQ',\n  /** Guyana Dollar */\n  Gyd = 'GYD',\n  /** Hong Kong Dollar */\n  Hkd = 'HKD',\n  /** Lempira */\n  Hnl = 'HNL',\n  /** Kuna */\n  Hrk = 'HRK',\n  /** Gourde */\n  Htg = 'HTG',\n  /** Forint */\n  Huf = 'HUF',\n  /** Rupiah */\n  Idr = 'IDR',\n  /** New Israeli Sheqel */\n  Ils = 'ILS',\n  /** Indian Rupee */\n  Inr = 'INR',\n  /** Iraqi Dinar */\n  Iqd = 'IQD',\n  /** Iranian Rial */\n  Irr = 'IRR',\n  /** Iceland Krona */\n  Isk = 'ISK',\n  /** Jamaican Dollar */\n  Jmd = 'JMD',\n  /** Jordanian Dinar */\n  Jod = 'JOD',\n  /** Yen */\n  Jpy = 'JPY',\n  /** Kenyan Shilling */\n  Kes = 'KES',\n  /** Som */\n  Kgs = 'KGS',\n  /** Riel */\n  Khr = 'KHR',\n  /** Comorian Franc */\n  Kmf = 'KMF',\n  /** North Korean Won */\n  Kpw = 'KPW',\n  /** Won */\n  Krw = 'KRW',\n  /** Kuwaiti Dinar */\n  Kwd = 'KWD',\n  /** Cayman Islands Dollar */\n  Kyd = 'KYD',\n  /** Tenge */\n  Kzt = 'KZT',\n  /** Lao Kip */\n  Lak = 'LAK',\n  /** Lebanese Pound */\n  Lbp = 'LBP',\n  /** Sri Lanka Rupee */\n  Lkr = 'LKR',\n  /** Liberian Dollar */\n  Lrd = 'LRD',\n  /** Loti */\n  Lsl = 'LSL',\n  /** Libyan Dinar */\n  Lyd = 'LYD',\n  /** Moroccan Dirham */\n  Mad = 'MAD',\n  /** Moldovan Leu */\n  Mdl = 'MDL',\n  /** Malagasy Ariary */\n  Mga = 'MGA',\n  /** Denar */\n  Mkd = 'MKD',\n  /** Kyat */\n  Mmk = 'MMK',\n  /** Tugrik */\n  Mnt = 'MNT',\n  /** Pataca */\n  Mop = 'MOP',\n  /** Ouguiya */\n  Mru = 'MRU',\n  /** Mauritius Rupee */\n  Mur = 'MUR',\n  /** Rufiyaa */\n  Mvr = 'MVR',\n  /** Malawi Kwacha */\n  Mwk = 'MWK',\n  /** Mexican Peso */\n  Mxn = 'MXN',\n  /** Mexican Unidad de Inversion (UDI) */\n  Mxv = 'MXV',\n  /** Malaysian Ringgit */\n  Myr = 'MYR',\n  /** Mozambique Metical */\n  Mzn = 'MZN',\n  /** Namibia Dollar */\n  Nad = 'NAD',\n  /** Naira */\n  Ngn = 'NGN',\n  /** Cordoba Oro */\n  Nio = 'NIO',\n  /** Norwegian Krone */\n  Nok = 'NOK',\n  /** Nepalese Rupee */\n  Npr = 'NPR',\n  /** New Zealand Dollar */\n  Nzd = 'NZD',\n  /** Rial Omani */\n  Omr = 'OMR',\n  /** Balboa */\n  Pab = 'PAB',\n  /** Sol */\n  Pen = 'PEN',\n  /** Kina */\n  Pgk = 'PGK',\n  /** Philippine Peso */\n  Php = 'PHP',\n  /** Pakistan Rupee */\n  Pkr = 'PKR',\n  /** Zloty */\n  Pln = 'PLN',\n  /** Guarani */\n  Pyg = 'PYG',\n  /** Qatari Rial */\n  Qar = 'QAR',\n  /** Romanian Leu */\n  Ron = 'RON',\n  /** Serbian Dinar */\n  Rsd = 'RSD',\n  /** Russian Ruble */\n  Rub = 'RUB',\n  /** Rwanda Franc */\n  Rwf = 'RWF',\n  /** Saudi Riyal */\n  Sar = 'SAR',\n  /** Solomon Islands Dollar */\n  Sbd = 'SBD',\n  /** Seychelles Rupee */\n  Scr = 'SCR',\n  /** Sudanese Pound */\n  Sdg = 'SDG',\n  /** Swedish Krona */\n  Sek = 'SEK',\n  /** Singapore Dollar */\n  Sgd = 'SGD',\n  /** Saint Helena Pound */\n  Shp = 'SHP',\n  /** Leone 2022 */\n  Sle = 'SLE',\n  /** Leone */\n  Sll = 'SLL',\n  /** Somali Shilling */\n  Sos = 'SOS',\n  /** Surinam Dollar */\n  Srd = 'SRD',\n  /** South Sudanese Pound */\n  Ssp = 'SSP',\n  /** Dobra */\n  Stn = 'STN',\n  /** El Salvador Colon */\n  Svc = 'SVC',\n  /** Syrian Pound */\n  Syp = 'SYP',\n  /** Lilangeni */\n  Szl = 'SZL',\n  /** Baht */\n  Thb = 'THB',\n  /** Somoni */\n  Tjs = 'TJS',\n  /** Turkmenistan New Manat */\n  Tmt = 'TMT',\n  /** Tunisian Dinar */\n  Tnd = 'TND',\n  /** Pa'anga */\n  Top = 'TOP',\n  /** Turkish Lira */\n  Try = 'TRY',\n  /** Trinidad and Tobago Dollar */\n  Ttd = 'TTD',\n  /** New Taiwan Dollar */\n  Twd = 'TWD',\n  /** Tanzanian Shilling */\n  Tzs = 'TZS',\n  /** Hryvnia */\n  Uah = 'UAH',\n  /** Uganda Shilling */\n  Ugx = 'UGX',\n  /** US Dollar */\n  Usd = 'USD',\n  /** Uruguay Peso en Unidades Indexadas (UI) */\n  Uyi = 'UYI',\n  /** Peso Uruguayo */\n  Uyu = 'UYU',\n  /** Unidad Previsional */\n  Uyw = 'UYW',\n  /** Uzbekistan Sum */\n  Uzs = 'UZS',\n  /** Bolívar Soberano */\n  Ves = 'VES',\n  /** Dong */\n  Vnd = 'VND',\n  /** Vatu */\n  Vuv = 'VUV',\n  /** Tala */\n  Wst = 'WST',\n  /** CFA Franc BEAC */\n  Xaf = 'XAF',\n  /** East Caribbean Dollar */\n  Xcd = 'XCD',\n  /** CFA Franc BCEAO */\n  Xof = 'XOF',\n  /** CFP Franc */\n  Xpf = 'XPF',\n  /** Yemeni Rial */\n  Yer = 'YER',\n  /** Rand */\n  Zar = 'ZAR',\n  /** Zambian Kwacha */\n  Zmw = 'ZMW',\n  /** Zimbabwe Dollar */\n  Zwl = 'ZWL'\n}\n\n/** An enumeration. */\nexport enum OrganisationsOrganisationExperienceLevelChoices {\n  /** BEGINNER */\n  Beginner = 'BEGINNER',\n  /** EXPERIENCED */\n  Experienced = 'EXPERIENCED'\n}\n\n/** An enumeration. */\nexport enum OrganisationsOrganisationShareCertificateTypeChoices {\n  /** Holdings */\n  ShareCertificateHoldings = 'SHARE_CERTIFICATE_HOLDINGS',\n  /** Transactional */\n  ShareCertificateTransactional = 'SHARE_CERTIFICATE_TRANSACTIONAL'\n}\n\n/** An enumeration. */\nexport enum OrganisationsOrganisationUserRolePositionChoices {\n  /** Attorney */\n  Attorney = 'ATTORNEY',\n  /** Co-founder */\n  Cofounder = 'COFOUNDER',\n  /** Finance */\n  Finance = 'FINANCE',\n  /** HR */\n  Hr = 'HR'\n}\n\n/** An enumeration. */\nexport enum OrganisationsOrganisationUserRoleRoleChoices {\n  /** Account Owner */\n  Admin = 'ADMIN',\n  /** Admin */\n  Advisor = 'ADVISOR',\n  /** Edit */\n  Edit = 'EDIT',\n  /** Support Admin */\n  Support = 'SUPPORT',\n  /** View only */\n  View = 'VIEW'\n}\n\n/** An enumeration. */\nexport enum OrganisationsOrganisationValuationRequestStatusChoices {\n  /** No Valuation Requested */\n  NoValuationRequested = 'NO_VALUATION_REQUESTED',\n  /** Valuation Complete */\n  ValuationComplete = 'VALUATION_COMPLETE',\n  /** Valuation in Progress */\n  ValuationInProgress = 'VALUATION_IN_PROGRESS',\n  /** Valuation Requested */\n  ValuationRequested = 'VALUATION_REQUESTED'\n}\n\n/** An enumeration. */\nexport enum OrganisationsValuationRoundChoices {\n  /** Pre-seed */\n  PreSeed = 'PRE_SEED',\n  /** Pre-seed Bridging */\n  PreSeedBridging = 'PRE_SEED_BRIDGING',\n  /** Seed */\n  Seed = 'SEED',\n  /** Seed  Bridging */\n  SeedBridging = 'SEED_BRIDGING',\n  /** Series A */\n  SeriesA = 'SERIES_A',\n  /** Series A Bridging */\n  SeriesABridging = 'SERIES_A_BRIDGING',\n  /** Series B */\n  SeriesB = 'SERIES_B',\n  /** Series B Bridging */\n  SeriesBBridging = 'SERIES_B_BRIDGING',\n  /** Series C */\n  SeriesC = 'SERIES_C',\n  /** Series C Bridging */\n  SeriesCBridging = 'SERIES_C_BRIDGING',\n  /** Series D */\n  SeriesD = 'SERIES_D'\n}\n\nexport type OverviewSecuritiesBreakdownType = {\n  __typename?: 'OverviewSecuritiesBreakdownType';\n  sharetypeHoldings?: Maybe<Array<Maybe<SharetypeHoldingType>>>;\n  totalNotesInvestment?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalOfferedRsus?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalOptions?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalUnallocatedRsus?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalUnallocatedShares?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalWarrants?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type OverviewShareholderType = {\n  __typename?: 'OverviewShareholderType';\n  avatar?: Maybe<Scalars['String']['output']>;\n  consideredInvited?: Maybe<Scalars['Boolean']['output']>;\n  displayName?: Maybe<Scalars['String']['output']>;\n  email?: Maybe<Scalars['String']['output']>;\n  hasLoggedIn?: Maybe<Scalars['Boolean']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  isTrust?: Maybe<Scalars['Boolean']['output']>;\n  secondaryName?: Maybe<Scalars['String']['output']>;\n  sharetypeHoldings?: Maybe<Array<Maybe<SharetypeHoldingType>>>;\n  stakeholderType?: Maybe<Scalars['String']['output']>;\n  totalConvertibleNotesInvestment?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalSafeNotesInvestment?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalSecurities?: Maybe<Scalars['BigInt']['output']>;\n  totalShares?: Maybe<Scalars['BigInt']['output']>;\n  totalUnvestedOptions?: Maybe<Scalars['BigInt']['output']>;\n  totalUnvestedRsus?: Maybe<Scalars['BigInt']['output']>;\n  totalUnvestedWarrants?: Maybe<Scalars['BigInt']['output']>;\n  totalVestedOptions?: Maybe<Scalars['BigInt']['output']>;\n  totalVestedRsus?: Maybe<Scalars['BigInt']['output']>;\n  totalVestedWarrants?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type PaginatedActionItems = {\n  __typename?: 'PaginatedActionItems';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<ActionItemOutputType>>>;\n  recent?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type PaginatedActivityLogEntryType = {\n  __typename?: 'PaginatedActivityLogEntryType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<ActivityLogEntryType>>>;\n};\n\nexport type PaginatedAnyOfferType = {\n  __typename?: 'PaginatedAnyOfferType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<AnyVestableOffer>>>;\n};\n\nexport type PaginatedBillingStakeholder = {\n  __typename?: 'PaginatedBillingStakeholder';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<BillingStakeholder>>>;\n};\n\nexport type PaginatedBoardApprovalType = {\n  __typename?: 'PaginatedBoardApprovalType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<BoardApprovalType>>>;\n};\n\nexport type PaginatedDocuments = {\n  __typename?: 'PaginatedDocuments';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<Document>>>;\n};\n\nexport type PaginatedEquityRoundOffersType = {\n  __typename?: 'PaginatedEquityRoundOffersType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<OrganisationRaiseOffer>>>;\n};\n\nexport type PaginatedEsopOffer = {\n  __typename?: 'PaginatedEsopOffer';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  notSignedUpCount?: Maybe<Scalars['Int']['output']>;\n  pageData?: Maybe<Array<Maybe<ListContextVestingOfferType>>>;\n  plan?: Maybe<Esop>;\n  shareholderCount?: Maybe<Scalars['Int']['output']>;\n};\n\nexport type PaginatedEssOffer = {\n  __typename?: 'PaginatedEssOffer';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  notSignedUpCount?: Maybe<Scalars['Int']['output']>;\n  pageData?: Maybe<Array<Maybe<ListContextVestingOfferType>>>;\n  plan?: Maybe<Ess>;\n  shareholderCount?: Maybe<Scalars['Int']['output']>;\n};\n\nexport type PaginatedHistorical409AType = {\n  __typename?: 'PaginatedHistorical409AType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<Historical409AType>>>;\n};\n\nexport type PaginatedInboxListType = {\n  __typename?: 'PaginatedInboxListType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData: Array<InboxItemType>;\n};\n\nexport type PaginatedMessageAnalyticsType = {\n  __typename?: 'PaginatedMessageAnalyticsType';\n  allowReactions?: Maybe<Scalars['Boolean']['output']>;\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  messageId?: Maybe<Scalars['UUID']['output']>;\n  pageData?: Maybe<Array<Maybe<MessageAnalyticsEntryType>>>;\n  uniqueOpenCount?: Maybe<Scalars['Int']['output']>;\n};\n\nexport type PaginatedMessageType = {\n  __typename?: 'PaginatedMessageType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<CakeMessageType>>>;\n};\n\nexport type PaginatedNextVestingEvents = {\n  __typename?: 'PaginatedNextVestingEvents';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  imminentEventsCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  pageData?: Maybe<Array<Maybe<NextVestingEventEntry>>>;\n};\n\nexport type PaginatedNoteOffer = {\n  __typename?: 'PaginatedNoteOffer';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  notSignedUpCount: Scalars['Int']['output'];\n  pageData: Array<ListContextNoteOfferType>;\n  shareholderCount: Scalars['Int']['output'];\n};\n\nexport type PaginatedNoteTransaction = {\n  __typename?: 'PaginatedNoteTransaction';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<NoteTransaction>>>;\n};\n\nexport type PaginatedOffboardingOutputType = {\n  __typename?: 'PaginatedOffboardingOutputType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<OffboardingOutputType>>>;\n};\n\nexport type PaginatedOptionExerciseRequestType = {\n  __typename?: 'PaginatedOptionExerciseRequestType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<OptionExerciseRequestType>>>;\n};\n\nexport type PaginatedOverviewShareholderType = {\n  __typename?: 'PaginatedOverviewShareholderType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<OverviewShareholderType>>>;\n};\n\nexport type PaginatedPeopleType = {\n  __typename?: 'PaginatedPeopleType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  notSignedUpCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  pageData?: Maybe<Array<Maybe<PersonType>>>;\n};\n\nexport type PaginatedPostGrantEditabilityType = {\n  __typename?: 'PaginatedPostGrantEditabilityType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<PostGrantEditabilityType>>>;\n  uneditableCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type PaginatedQsbsTransactionType = {\n  __typename?: 'PaginatedQsbsTransactionType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<QsbsTransactionType>>>;\n};\n\nexport type PaginatedRsuOffer = {\n  __typename?: 'PaginatedRsuOffer';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  notSignedUpCount?: Maybe<Scalars['Int']['output']>;\n  pageData?: Maybe<Array<Maybe<ListContextRsuOfferType>>>;\n  plan?: Maybe<RsuOutputType>;\n  shareholderCount?: Maybe<Scalars['Int']['output']>;\n};\n\nexport type PaginatedSentKudosType = {\n  __typename?: 'PaginatedSentKudosType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<SentKudosType>>>;\n};\n\nexport type PaginatedShareTransferOfferType = {\n  __typename?: 'PaginatedShareTransferOfferType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<ShareTransferOfferType>>>;\n};\n\nexport type PaginatedShareTransferRoundType = {\n  __typename?: 'PaginatedShareTransferRoundType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<ShareTransferRoundType>>>;\n};\n\nexport type PaginatedShareholderHoldingsType = {\n  __typename?: 'PaginatedShareholderHoldingsType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  notSignedUpCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  pageData?: Maybe<Array<Maybe<Shareholder>>>;\n};\n\nexport type PaginatedShareholderListType = {\n  __typename?: 'PaginatedShareholderListType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  notSignedUpCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  pageData?: Maybe<Array<Maybe<ListContextShareholderType>>>;\n};\n\nexport type PaginatedShareholderType = {\n  __typename?: 'PaginatedShareholderType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  notSignedUpCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  pageData?: Maybe<Array<Maybe<Shareholder>>>;\n};\n\nexport type PaginatedShareholdersWithVestableHoldingsType = {\n  __typename?: 'PaginatedShareholdersWithVestableHoldingsType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  notSignedUpCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  pageData?: Maybe<Array<Maybe<ShareholderWithVestableHoldingsType>>>;\n};\n\nexport type PaginatedShareholdingTransaction = {\n  __typename?: 'PaginatedShareholdingTransaction';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<ShareholdingTransaction>>>;\n};\n\nexport type PaginatedStringList = {\n  __typename?: 'PaginatedStringList';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData: Array<Scalars['CleanString']['output']>;\n};\n\nexport type PaginatedTransferSenderType = {\n  __typename?: 'PaginatedTransferSenderType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<TransferSenderType>>>;\n};\n\nexport type PaginatedUserType = {\n  __typename?: 'PaginatedUserType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<UserType>>>;\n};\n\nexport type PaginatedVestingPlanTransaction = {\n  __typename?: 'PaginatedVestingPlanTransaction';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<VestingPlanTransaction>>>;\n};\n\nexport type PaginatedVestingScheduleTemplateType = {\n  __typename?: 'PaginatedVestingScheduleTemplateType';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  pageData?: Maybe<Array<Maybe<VestingScheduleTemplateType>>>;\n};\n\nexport type PaginatedWarrantOffer = {\n  __typename?: 'PaginatedWarrantOffer';\n  count: Scalars['Int']['output'];\n  currentPage: Scalars['Int']['output'];\n  notSignedUpCount?: Maybe<Scalars['Int']['output']>;\n  pageData?: Maybe<Array<Maybe<ListContextVestingOfferType>>>;\n  plan?: Maybe<WarrantOutputType>;\n  shareholderCount?: Maybe<Scalars['Int']['output']>;\n};\n\nexport type PaymentDetailsField = AuPaymentDetailsType | FallbackPaymentDetailsType | SgPaymentDetailsType;\n\nexport type PaymentDetailsOutputType = {\n  __typename?: 'PaymentDetailsOutputType';\n  accountName?: Maybe<Scalars['String']['output']>;\n  accountNumber?: Maybe<Scalars['String']['output']>;\n  additionalInstructions?: Maybe<Scalars['String']['output']>;\n  routingNumber?: Maybe<Scalars['String']['output']>;\n};\n\nexport type PersonType = {\n  __typename?: 'PersonType';\n  avatar?: Maybe<Scalars['CleanString']['output']>;\n  consideredInvited?: Maybe<Scalars['Boolean']['output']>;\n  displayName?: Maybe<Scalars['CleanString']['output']>;\n  hasLoggedIn?: Maybe<Scalars['Boolean']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  identificationCode?: Maybe<Scalars['CleanString']['output']>;\n  messagesCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  primaryAddress?: Maybe<InternationalAddressField>;\n  primaryEmail?: Maybe<Scalars['CleanString']['output']>;\n  primaryName?: Maybe<Scalars['CleanString']['output']>;\n  primaryPhone?: Maybe<Scalars['CleanString']['output']>;\n  secondaryAddress?: Maybe<InternationalAddressField>;\n  secondaryEmail?: Maybe<Scalars['CleanString']['output']>;\n  secondaryName?: Maybe<Scalars['CleanString']['output']>;\n  secondaryPhone?: Maybe<Scalars['CleanString']['output']>;\n  sharedDocumentsCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  shareholderType?: Maybe<Scalars['CleanString']['output']>;\n  trustName?: Maybe<Scalars['CleanString']['output']>;\n};\n\nexport type PortfolioHomeOutputType = {\n  __typename?: 'PortfolioHomeOutputType';\n  groupedNoteholdings?: Maybe<Array<Maybe<GroupedNoteholdingType>>>;\n  groupedPlanData?: Maybe<Array<Maybe<PortfolioPlanHoldingOutputType>>>;\n  groupedShareholdings?: Maybe<Array<Maybe<GroupedShareholdingType>>>;\n  groupedShareholdingsInTrust?: Maybe<Array<Maybe<GroupedShareholdingInTrustType>>>;\n  shareholder?: Maybe<Shareholder>;\n  shareholdings?: Maybe<Array<Maybe<ShareholdingType>>>;\n};\n\n\nexport type PortfolioHomeOutputTypeGroupedNoteholdingsArgs = {\n  excludeResolved?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\nexport type PortfolioHomeOutputTypeShareholdingsArgs = {\n  includeBeneficiary?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\nexport type PortfolioPlanHoldingOutputType = {\n  __typename?: 'PortfolioPlanHoldingOutputType';\n  fullCalendar?: Maybe<OfferCalendarOutputType>;\n  planType?: Maybe<VestingPlanType>;\n  shareholder?: Maybe<Shareholder>;\n  totalExercised?: Maybe<Scalars['BigInt']['output']>;\n  totalGranted?: Maybe<Scalars['BigInt']['output']>;\n  totalLapsed?: Maybe<Scalars['BigInt']['output']>;\n  totalVested?: Maybe<Scalars['BigInt']['output']>;\n  vestingNext?: Maybe<VestingCalendarOutputEntry>;\n};\n\nexport type PositionWithDescription = {\n  __typename?: 'PositionWithDescription';\n  description?: Maybe<Scalars['String']['output']>;\n  position?: Maybe<Scalars['String']['output']>;\n};\n\nexport type PostGrantEditabilityType = {\n  __typename?: 'PostGrantEditabilityType';\n  avatar?: Maybe<Scalars['String']['output']>;\n  canEdit?: Maybe<Scalars['Boolean']['output']>;\n  displayName?: Maybe<Scalars['String']['output']>;\n  email?: Maybe<Scalars['String']['output']>;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  reasons?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\nexport type PtepSettingsOutputType = {\n  __typename?: 'PtepSettingsOutputType';\n  complete: Scalars['Boolean']['output'];\n  created: Scalars['DateTime']['output'];\n  esopoffer?: Maybe<EsopOffer>;\n  esopoffergroup?: Maybe<EsopOfferGroup>;\n  /** Date when the reminder to exercise vestable was sent. If there is no date, no reminder was sent. */\n  exerciseReminderDate?: Maybe<Scalars['Date']['output']>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** Time period after termination when vestable can be exercised */\n  ptepInterval: TimeSliceType;\n  /** Whether to send exercise reminder to the employee */\n  sendExerciseReminder: Scalars['Boolean']['output'];\n  warrantoffer?: Maybe<WarrantOfferOutputType>;\n};\n\nexport type QsbsFormInputType = {\n  cutoffDate?: InputMaybe<Scalars['Date']['input']>;\n  grossAfterBbb?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  grossBeforeBbb?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  naics: Scalars['String']['input'];\n};\n\nexport type QsbsTransactionType = {\n  __typename?: 'QsbsTransactionType';\n  displayName?: Maybe<Scalars['CleanString']['output']>;\n  hasVestingEvent?: Maybe<Scalars['Boolean']['output']>;\n  qsbsSharesWith83b?: Maybe<Scalars['PositiveInteger']['output']>;\n  qsbsSharesWithout83b?: Maybe<Scalars['PositiveInteger']['output']>;\n  shareholderId?: Maybe<Scalars['UUID']['output']>;\n  sharetypeName?: Maybe<Scalars['CleanString']['output']>;\n  transactionDate?: Maybe<Scalars['Date']['output']>;\n  transactionId?: Maybe<Scalars['UUID']['output']>;\n};\n\nexport type QuarterlyNewStakeholder = {\n  __typename?: 'QuarterlyNewStakeholder';\n  avatar?: Maybe<Scalars['String']['output']>;\n  displayName?: Maybe<Scalars['String']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n};\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type Query = {\n  __typename?: 'Query';\n  _debug?: Maybe<DjangoDebug>;\n  actionItems?: Maybe<PaginatedActionItems>;\n  activityLogContextNames?: Maybe<Array<Maybe<Array<Maybe<Scalars['String']['output']>>>>>;\n  activityLogEntries?: Maybe<PaginatedActivityLogEntryType>;\n  adminOrganisations?: Maybe<Array<Maybe<Organisation>>>;\n  availableOfficeholderRoles?: Maybe<Array<Maybe<RoleType>>>;\n  availableOrganisationPositions?: Maybe<AvailableOrganisationPositions>;\n  availableOrganisationRoles?: Maybe<AvailableOrganisationRoles>;\n  availableTemplateTypes?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n  billingStakeholders?: Maybe<PaginatedBillingStakeholder>;\n  boardApprovalDetails?: Maybe<BoardApprovalType>;\n  boardApprovals?: Maybe<PaginatedBoardApprovalType>;\n  cakeGroups?: Maybe<Array<Maybe<CakeGroupType>>>;\n  canChangeEmail?: Maybe<Scalars['Boolean']['output']>;\n  canEditOnboardedShareholders?: Maybe<Scalars['Boolean']['output']>;\n  canRequestExercise?: Maybe<Scalars['Boolean']['output']>;\n  dashboardEsopAggregate?: Maybe<DashboardEsopAggregate>;\n  dashboardNextVestingEvents?: Maybe<PaginatedNextVestingEvents>;\n  dashboardOwnership?: Maybe<DashboardOwnership>;\n  dashboardSecurities?: Maybe<DashboardSecurities>;\n  dashboardShareholdersPerQuarter?: Maybe<Array<Maybe<TotalsQuarterEntry>>>;\n  dashboardStatistics?: Maybe<DashboardStatistics>;\n  dashboardTopStakeholders?: Maybe<DashboardTopStakeholders>;\n  debugCacheStatistics?: Maybe<Scalars['String']['output']>;\n  debugClearDailyVestCache?: Maybe<Scalars['Boolean']['output']>;\n  debugConsolidateCapTable?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  debugEsopCalendar?: Maybe<OfferCalendarOutputType>;\n  debugEssCalendar?: Maybe<OfferCalendarOutputType>;\n  debugFounderVestingCalendar?: Maybe<OfferCalendarOutputType>;\n  debugInvalidateCache?: Maybe<Scalars['Int']['output']>;\n  debugInvalidateShareholdersPerQuarterCache?: Maybe<Scalars['Int']['output']>;\n  debugInvalidateStripeTiersAndAddonsCache?: Maybe<Scalars['Boolean']['output']>;\n  debugTriggerEndedDisclosures?: Maybe<Scalars['Boolean']['output']>;\n  debugWarrantCalendar?: Maybe<OfferCalendarOutputType>;\n  digestedPlanTransactions?: Maybe<PaginatedVestingPlanTransaction>;\n  document?: Maybe<Document>;\n  echoPrivate?: Maybe<Scalars['Boolean']['output']>;\n  echoPublic?: Maybe<Scalars['Boolean']['output']>;\n  equityModels?: Maybe<Array<Maybe<EquityModelOutputType>>>;\n  equityRounds?: Maybe<Array<Maybe<OrganisationRaise>>>;\n  esopOffer?: Maybe<EsopOffer>;\n  esopOfferDetails?: Maybe<EsopOffer>;\n  esopOfferGroup?: Maybe<EsopOfferGroup>;\n  esopOfferList?: Maybe<Array<Maybe<EsopOffer>>>;\n  esopOffersEligibleForApproval?: Maybe<Array<Maybe<EsopOfferApprovalItem>>>;\n  esopOffersToComplete?: Maybe<Array<Maybe<EsopOffer>>>;\n  esops?: Maybe<Array<Maybe<Esop>>>;\n  essOffer?: Maybe<EssOffer>;\n  essOfferDetails?: Maybe<EssOffer>;\n  essOfferGroup?: Maybe<EssOfferGroup>;\n  essOfferList?: Maybe<Array<Maybe<EssOffer>>>;\n  essOffersToComplete?: Maybe<Array<Maybe<EssOffer>>>;\n  essOffersVestingEvents?: Maybe<Array<Maybe<EssVestingEventType>>>;\n  esss?: Maybe<Array<Maybe<Ess>>>;\n  exerciseRequest?: Maybe<OptionExerciseRequestType>;\n  exerciseRequestSettings?: Maybe<OptionExerciseRequestSettingsType>;\n  exerciseRequests?: Maybe<PaginatedOptionExerciseRequestType>;\n  exerciseRequestsFromOffer?: Maybe<PaginatedOptionExerciseRequestType>;\n  founderVestingOffer?: Maybe<FounderVestingOfferOutputType>;\n  founderVestingOfferDetails?: Maybe<FounderVestingOfferOutputType>;\n  founderVestingOfferGroup?: Maybe<FounderVestingOfferGroupOutputType>;\n  founderVestingOfferList?: Maybe<Array<Maybe<FounderVestingOfferOutputType>>>;\n  founderVestingOffersToComplete?: Maybe<Array<Maybe<FounderVestingOfferOutputType>>>;\n  founderVestingOffersVestingEvents?: Maybe<Array<Maybe<FounderVestingVestingEventOutputType>>>;\n  founderVestings?: Maybe<Array<Maybe<FounderVestingOutputType>>>;\n  getAvailableUsersForCakeGroup?: Maybe<Array<Maybe<GroupUser>>>;\n  getBillingAvatar?: Maybe<BillingAvatar>;\n  getBillingDetails?: Maybe<BillingDetails>;\n  getCakePlansV5?: Maybe<Array<Maybe<CakePlanType>>>;\n  getChecklist?: Maybe<Array<Maybe<ChecklistItem>>>;\n  getComments?: Maybe<Array<Maybe<CommentType>>>;\n  getCouponData?: Maybe<CouponType>;\n  getInvitedUsers?: Maybe<Array<Maybe<EmailSenderType>>>;\n  getInvoices?: Maybe<Array<Maybe<Invoice>>>;\n  getOneTimeAddonPrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  getPeople?: Maybe<PaginatedPeopleType>;\n  getPotentialTransferSenders?: Maybe<PaginatedTransferSenderType>;\n  getReminderEmail?: Maybe<ReminderEmailType>;\n  getShareSplitDetails?: Maybe<Array<Maybe<ShareSplitDetailType>>>;\n  getSupportedShareholders?: Maybe<Array<Maybe<Shareholder>>>;\n  getTrustees?: Maybe<Array<Maybe<Shareholder>>>;\n  homeEntrypoint?: Maybe<HomeEntrypointType>;\n  investorEquityOffer?: Maybe<OrganisationRaiseOffer>;\n  investorFounderVestHoldings?: Maybe<GroupedFounderVestHoldingType>;\n  investorInbox: PaginatedInboxListType;\n  investorMessageThread?: Maybe<CakeReplyThreadType>;\n  investorMessages?: Maybe<PaginatedMessageType>;\n  investorNoteOffer?: Maybe<NotesRoundOfferType>;\n  investorNotes?: Maybe<Array<Maybe<Note>>>;\n  investorOptionholdings?: Maybe<GroupedOptionholdingType>;\n  investorShareVestHoldings?: Maybe<GroupedShareVestHoldingType>;\n  investorShareholders?: Maybe<Array<Maybe<Shareholder>>>;\n  investorWarrantHoldings?: Maybe<GroupedWarrantHoldingType>;\n  isCaptableSensitive?: Maybe<Scalars['Boolean']['output']>;\n  isTransactionEditable?: Maybe<Scalars['Boolean']['output']>;\n  lastFinancialYear?: Maybe<Scalars['Int']['output']>;\n  latestHistorical409a?: Maybe<Historical409AType>;\n  list409aValuations?: Maybe<PaginatedHistorical409AType>;\n  listFiles?: Maybe<PaginatedDocuments>;\n  listFolders?: Maybe<Array<Maybe<Document>>>;\n  messageAnalytics?: Maybe<PaginatedMessageAnalyticsType>;\n  notSignedUpShareholders?: Maybe<NotSignedUpShareholdersResultType>;\n  note?: Maybe<Note>;\n  notesOffer?: Maybe<NotesRoundOfferType>;\n  notesOffers?: Maybe<PaginatedNoteOffer>;\n  notesRoundOffers?: Maybe<Array<Maybe<NotesRoundOfferType>>>;\n  notesRounds?: Maybe<Array<Maybe<NotesRoundType>>>;\n  notesRoundsNames?: Maybe<PaginatedStringList>;\n  offboarding?: Maybe<OffboardingOutputType>;\n  offboardingDetailsEsop?: Maybe<EsopOffer>;\n  offboardingDetailsEss?: Maybe<EssOffer>;\n  offboardingDetailsFounderVesting?: Maybe<FounderVestingOfferOutputType>;\n  offboardingDetailsRsu?: Maybe<RsuOfferOutputType>;\n  offboardings?: Maybe<PaginatedOffboardingOutputType>;\n  offersPostGrantExercisePriceEditabilityEsop?: Maybe<PaginatedPostGrantEditabilityType>;\n  offersPostGrantExpirationEditabilityEsop?: Maybe<PaginatedPostGrantEditabilityType>;\n  offersPostGrantGrantDateEditabilityEsop?: Maybe<PaginatedPostGrantEditabilityType>;\n  offersPostGrantOptionPriceEditabilityEsop?: Maybe<PaginatedPostGrantEditabilityType>;\n  offersPostGrantPtepEditabilityEsop?: Maybe<PaginatedPostGrantEditabilityType>;\n  officeholders?: Maybe<Array<Maybe<Officeholder>>>;\n  optionExerciseRequest?: Maybe<OptionExerciseRequestType>;\n  optionPoolOffers?: Maybe<PaginatedEsopOffer>;\n  optionPoolOffersVestingEvents?: Maybe<Array<Maybe<EsopVestingEventType>>>;\n  orgCountriesAndStates?: Maybe<CountriesAndStatesType>;\n  organisation?: Maybe<Organisation>;\n  organisationAllowMessageReplies: Scalars['Boolean']['output'];\n  organisationDocuments?: Maybe<PaginatedDocuments>;\n  organisationInbox: PaginatedInboxListType;\n  organisationMessageThread?: Maybe<CakeReplyThreadType>;\n  organisationMfaStatus?: Maybe<Scalars['Boolean']['output']>;\n  organisationNotesTransactions?: Maybe<PaginatedNoteTransaction>;\n  organisationPreDeletionReport?: Maybe<OrganisationPreDeletionReportType>;\n  organisationShareholdingTransactions?: Maybe<PaginatedShareholdingTransaction>;\n  organisationSupportSearch?: Maybe<Array<Maybe<Organisation>>>;\n  organisationUserRolePosition?: Maybe<OrganisationUserRolePositionType>;\n  organisationUserRoles?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n  paginatedShareholders?: Maybe<PaginatedShareholderType>;\n  platformVersion?: Maybe<Scalars['String']['output']>;\n  portfolioHome?: Maybe<Array<Maybe<PortfolioHomeOutputType>>>;\n  qsbsTransactions?: Maybe<PaginatedQsbsTransactionType>;\n  raiseOffers?: Maybe<PaginatedEquityRoundOffersType>;\n  rsuOffer?: Maybe<RsuOfferOutputType>;\n  rsuOfferDetails?: Maybe<RsuOfferOutputType>;\n  rsuOfferGroup?: Maybe<RsuOfferGroupOutputType>;\n  rsuOfferList?: Maybe<Array<Maybe<RsuOfferOutputType>>>;\n  rsuOffersToComplete?: Maybe<Array<Maybe<RsuOfferOutputType>>>;\n  rsuOffersVestingEvents?: Maybe<Array<Maybe<RsuVestingEventOutputType>>>;\n  rsuPlanOffers?: Maybe<PaginatedRsuOffer>;\n  rsus?: Maybe<Array<Maybe<RsuOutputType>>>;\n  sbcOffers?: Maybe<PaginatedAnyOfferType>;\n  scanbotDocument?: Maybe<ScanbotDocumentType>;\n  scanbotDocuments?: Maybe<Array<Maybe<ScanbotDocumentType>>>;\n  sentKudos?: Maybe<PaginatedSentKudosType>;\n  shareCertificateDisclaimer?: Maybe<ShareCertificateDisclaimerType>;\n  shareCertificateDisclaimersList?: Maybe<Array<Maybe<ShareCertificateDisclaimerType>>>;\n  sharePlanOffers?: Maybe<PaginatedEssOffer>;\n  shareTransferOffer?: Maybe<ShareTransferOfferType>;\n  shareTransferOffers?: Maybe<PaginatedShareTransferOfferType>;\n  shareTransferRounds?: Maybe<PaginatedShareTransferRoundType>;\n  shareholderAvailableSharesToTransfer?: Maybe<Scalars['BigInt']['output']>;\n  shareholderDocs?: Maybe<PaginatedDocuments>;\n  shareholderDocument?: Maybe<Array<Maybe<Document>>>;\n  shareholderNames?: Maybe<Array<Maybe<Array<Maybe<Scalars['String']['output']>>>>>;\n  shareholderOffboardingOffers?: Maybe<ShareholderOffboardingOffersOutputType>;\n  shareholderTransactions?: Maybe<Shareholder>;\n  shareholders?: Maybe<Array<Maybe<Shareholder>>>;\n  shareholdersCount?: Maybe<Scalars['Int']['output']>;\n  shareholdersList?: Maybe<PaginatedShareholderListType>;\n  shareholdersOverview?: Maybe<PaginatedOverviewShareholderType>;\n  shareholdersReport?: Maybe<ReportResponse>;\n  shareholdersSecuritiesBreakdown?: Maybe<OverviewSecuritiesBreakdownType>;\n  shareholdersToOffboard?: Maybe<PaginatedShareholderType>;\n  shareholdersWithNoteholdings?: Maybe<PaginatedShareholderHoldingsType>;\n  shareholdersWithOptionholdings?: Maybe<PaginatedShareholdersWithVestableHoldingsType>;\n  shareholdersWithShareVestHoldings?: Maybe<PaginatedShareholderHoldingsType>;\n  shareholdersWithShareholdings?: Maybe<PaginatedShareholderHoldingsType>;\n  shareholdersWithSharesAtDate?: Maybe<Array<Maybe<Shareholder>>>;\n  shareholdersWithoutShareholdings?: Maybe<Array<Maybe<Shareholder>>>;\n  sharetypes?: Maybe<Array<Maybe<Sharetype>>>;\n  showSurvey?: Maybe<Scalars['Boolean']['output']>;\n  stakeholdersMergePreview?: Maybe<MergeStakeholdersPreviewType>;\n  supportAdminEntries?: Maybe<Array<Maybe<OrganisationUserRoleType>>>;\n  templateViewLink?: Maybe<Scalars['String']['output']>;\n  templatesByContractType?: Maybe<Array<Maybe<Document>>>;\n  transactionDetails?: Maybe<Array<Maybe<ShareholdingTransaction>>>;\n  unusedTime?: Maybe<Scalars['CakeDecimal']['output']>;\n  userEmployeeGoal?: Maybe<UserEmployeeGoalOutputType>;\n  userInviteSender?: Maybe<Scalars['String']['output']>;\n  userOffers?: Maybe<Array<Maybe<AnyOffer>>>;\n  userOrgStatus?: Maybe<Array<Maybe<UserOrganisationStatusType>>>;\n  userOrganisations?: Maybe<UserOrganisationsType>;\n  userOrganisationsSupportSearch?: Maybe<Array<Maybe<UserAssociatedOrganisationsType>>>;\n  userPreference?: Maybe<Scalars['Boolean']['output']>;\n  userPreferences?: Maybe<UserCompanyPreferencesType>;\n  userProfile?: Maybe<UserType>;\n  userSettings?: Maybe<UserSettingsOutputType>;\n  userVestingOffers?: Maybe<Array<Maybe<AnyVestableOffer>>>;\n  usersWithMfa?: Maybe<PaginatedUserType>;\n  vestingCliff?: Maybe<VestingCliffOutputType>;\n  vestingScheduleTemplates?: Maybe<PaginatedVestingScheduleTemplateType>;\n  viewEditOrganisations?: Maybe<Array<Maybe<Organisation>>>;\n  warrantDefaultPlanGroup?: Maybe<WarrantOfferGroupOutputType>;\n  warrantOffer?: Maybe<WarrantOfferOutputType>;\n  warrantOfferDetails?: Maybe<WarrantOfferOutputType>;\n  warrantOfferGroup?: Maybe<WarrantOfferGroupOutputType>;\n  warrantOfferList?: Maybe<Array<Maybe<WarrantOfferOutputType>>>;\n  warrantOffersToComplete?: Maybe<Array<Maybe<WarrantOfferOutputType>>>;\n  warrantOffersVestingEvents?: Maybe<Array<Maybe<WarrantVestingEventOutputType>>>;\n  warrantPlanOffers?: Maybe<PaginatedWarrantOffer>;\n  warrants?: Maybe<Array<Maybe<WarrantOutputType>>>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryActionItemsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page?: InputMaybe<Scalars['PositiveInteger']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryActivityLogContextNamesArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryActivityLogEntriesArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n  showSupportAdmin?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryAdminOrganisationsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryAvailableTemplateTypesArgs = {\n  countryCode: Scalars['CleanString']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryBillingStakeholdersArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryBoardApprovalDetailsArgs = {\n  boardApproval: Scalars['BoardApprovalCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryBoardApprovalsArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryCakeGroupsArgs = {\n  excludeByIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  excludeHidden?: InputMaybe<Scalars['Boolean']['input']>;\n  filterByGroupId?: InputMaybe<Scalars['UUID']['input']>;\n  onlyWithShareholders?: InputMaybe<Scalars['Boolean']['input']>;\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryCanEditOnboardedShareholdersArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryCanRequestExerciseArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDashboardEsopAggregateArgs = {\n  organisation?: InputMaybe<Scalars['OrganisationCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDashboardNextVestingEventsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisation?: InputMaybe<Scalars['OrganisationCakeType']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDashboardOwnershipArgs = {\n  organisation?: InputMaybe<Scalars['OrganisationCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDashboardSecuritiesArgs = {\n  organisation?: InputMaybe<Scalars['OrganisationCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDashboardShareholdersPerQuarterArgs = {\n  numberOfQuarters?: InputMaybe<Scalars['Int']['input']>;\n  organisation?: InputMaybe<Scalars['OrganisationCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDashboardStatisticsArgs = {\n  organisation?: InputMaybe<Scalars['OrganisationCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDashboardTopStakeholdersArgs = {\n  excludeOthersFromCount?: InputMaybe<Scalars['Boolean']['input']>;\n  n?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  organisation?: InputMaybe<Scalars['OrganisationCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDebugConsolidateCapTableArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDebugEsopCalendarArgs = {\n  merged?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['EsopOfferCakeType']['input'];\n  sampleEntries?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDebugEssCalendarArgs = {\n  merged?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['EssOfferCakeType']['input'];\n  sampleEntries?: InputMaybe<Scalars['Boolean']['input']>;\n  useLegacy?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDebugFounderVestingCalendarArgs = {\n  merged?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n  sampleEntries?: InputMaybe<Scalars['Boolean']['input']>;\n  useLegacy?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDebugInvalidateCacheArgs = {\n  organisationId?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDebugInvalidateShareholdersPerQuarterCacheArgs = {\n  organisationId?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDebugWarrantCalendarArgs = {\n  merged?: InputMaybe<Scalars['Boolean']['input']>;\n  offer: Scalars['WarrantOfferCakeType']['input'];\n  sampleEntries?: InputMaybe<Scalars['Boolean']['input']>;\n  useLegacy?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDigestedPlanTransactionsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  planType: VestingPlanType;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryDocumentArgs = {\n  document: Scalars['DocumentCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEchoPrivateArgs = {\n  echoStr?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEchoPublicArgs = {\n  echoStr?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEquityModelsArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEquityRoundsArgs = {\n  filterRound?: InputMaybe<Scalars['UUID']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEsopOfferArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEsopOfferDetailsArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEsopOfferGroupArgs = {\n  group: Scalars['EsopOfferGroupCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEsopOfferListArgs = {\n  employee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEsopOffersEligibleForApprovalArgs = {\n  esop: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEsopOffersToCompleteArgs = {\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  organisationId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEsopsArgs = {\n  filterPlan?: InputMaybe<Scalars['UUID']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEssOfferArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEssOfferDetailsArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEssOfferGroupArgs = {\n  group: Scalars['EssOfferGroupCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEssOfferListArgs = {\n  employee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEssOffersToCompleteArgs = {\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  organisationId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEssOffersVestingEventsArgs = {\n  offerIds: Array<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryEsssArgs = {\n  filterPlan?: InputMaybe<Scalars['UUID']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryExerciseRequestArgs = {\n  exerciseRequest: Scalars['OptionExerciseRequestCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryExerciseRequestSettingsArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryExerciseRequestsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryExerciseRequestsFromOfferArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  offer: Scalars['EsopOfferCakeType']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryFounderVestingOfferArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryFounderVestingOfferDetailsArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryFounderVestingOfferGroupArgs = {\n  group: Scalars['FounderVestingOfferGroupCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryFounderVestingOfferListArgs = {\n  employee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryFounderVestingOffersToCompleteArgs = {\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  organisationId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryFounderVestingOffersVestingEventsArgs = {\n  offerIds: Array<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryFounderVestingsArgs = {\n  filterPlan?: InputMaybe<Scalars['UUID']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetAvailableUsersForCakeGroupArgs = {\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetBillingAvatarArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetBillingDetailsArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetCakePlansV5Args = {\n  allowDowngrade?: InputMaybe<Scalars['Boolean']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetChecklistArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetCommentsArgs = {\n  instanceId: Scalars['UUID']['input'];\n  modelType: CommentModelTypeEnum;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetCouponDataArgs = {\n  coupon: Scalars['CleanString']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetInvitedUsersArgs = {\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetInvoicesArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetOneTimeAddonPriceArgs = {\n  cakeAddon: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetPeopleArgs = {\n  filters?: InputMaybe<Array<ListFilterType>>;\n  itemsPerPage: Scalars['Int']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['Int']['input'];\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']>>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetPotentialTransferSendersArgs = {\n  excludeByIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['Int']['input'];\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetReminderEmailArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetShareSplitDetailsArgs = {\n  transactionId?: InputMaybe<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryGetTrusteesArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryInvestorEquityOfferArgs = {\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryInvestorFounderVestHoldingsArgs = {\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryInvestorInboxArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  page: Scalars['PositiveInteger']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryInvestorMessageThreadArgs = {\n  replyThread: Scalars['CakeReplyThreadCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryInvestorMessagesArgs = {\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  page?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryInvestorNoteOfferArgs = {\n  offer?: InputMaybe<Scalars['NotesRoundOfferCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryInvestorNotesArgs = {\n  shareholder?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryInvestorOptionholdingsArgs = {\n  asOfDate?: InputMaybe<Scalars['Date']['input']>;\n  offer: Scalars['EsopOfferCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryInvestorShareVestHoldingsArgs = {\n  offer: Scalars['EssOfferCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryInvestorWarrantHoldingsArgs = {\n  offer: Scalars['WarrantOfferCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryIsCaptableSensitiveArgs = {\n  at?: InputMaybe<Scalars['Date']['input']>;\n  destructiveIntent?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype: Scalars['SharetypeCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryIsTransactionEditableArgs = {\n  transaction: Scalars['ShareholdingTransactionCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryLatestHistorical409aArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryList409aValuationsArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryListFilesArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  parentId?: InputMaybe<Scalars['UUID']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryListFoldersArgs = {\n  organisationId: Scalars['UUID']['input'];\n  parentId?: InputMaybe<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryMessageAnalyticsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  page?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  replyThread: Scalars['CakeReplyThreadCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryNotSignedUpShareholdersArgs = {\n  holdingsContext?: InputMaybe<Scalars['UUID']['input']>;\n  holdingsType: HoldingsType;\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryNoteArgs = {\n  note: Scalars['NoteCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryNotesOfferArgs = {\n  notesOffer: Scalars['NotesRoundOfferCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryNotesOffersArgs = {\n  filters?: InputMaybe<Array<ListFilterType>>;\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  noteType?: InputMaybe<NoteType>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']>>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryNotesRoundOffersArgs = {\n  filterOffer?: InputMaybe<Scalars['UUID']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n  round: Scalars['NotesRoundCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryNotesRoundsArgs = {\n  filterRound?: InputMaybe<Scalars['UUID']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryNotesRoundsNamesArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOffboardingArgs = {\n  offboarding: Scalars['OffboardingCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOffboardingDetailsEsopArgs = {\n  offer: Scalars['EsopOfferCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOffboardingDetailsEssArgs = {\n  offer: Scalars['EssOfferCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOffboardingDetailsFounderVestingArgs = {\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOffboardingDetailsRsuArgs = {\n  offer: Scalars['RsuOfferCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOffboardingsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page?: InputMaybe<Scalars['PositiveInteger']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOffersPostGrantExercisePriceEditabilityEsopArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  page: Scalars['PositiveInteger']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOffersPostGrantExpirationEditabilityEsopArgs = {\n  expirationData: OfferExerciseExpirationDataInputType;\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  page: Scalars['PositiveInteger']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOffersPostGrantGrantDateEditabilityEsopArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  page: Scalars['PositiveInteger']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOffersPostGrantOptionPriceEditabilityEsopArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  page: Scalars['PositiveInteger']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOffersPostGrantPtepEditabilityEsopArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  page: Scalars['PositiveInteger']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOfficeholdersArgs = {\n  excludeByIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  filterSigners?: InputMaybe<Scalars['Boolean']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOptionExerciseRequestArgs = {\n  exerciseRequest: Scalars['OptionExerciseRequestCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOptionPoolOffersArgs = {\n  filterId: Scalars['UUID']['input'];\n  filters?: InputMaybe<Array<ListFilterType>>;\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']>>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOptionPoolOffersVestingEventsArgs = {\n  offerIds: Array<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrgCountriesAndStatesArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationArgs = {\n  organisationId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationAllowMessageRepliesArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationDocumentsArgs = {\n  filterType?: InputMaybe<Scalars['String']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationInboxArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationMessageThreadArgs = {\n  replyThread: Scalars['CakeReplyThreadCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationMfaStatusArgs = {\n  organisationId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationNotesTransactionsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationPreDeletionReportArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationShareholdingTransactionsArgs = {\n  faultyOnly?: InputMaybe<Scalars['Boolean']['input']>;\n  filterType?: InputMaybe<Scalars['String']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationSupportSearchArgs = {\n  allowRepeat?: InputMaybe<Scalars['Boolean']['input']>;\n  maxResults?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationUserRolePositionArgs = {\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n  userId?: InputMaybe<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryOrganisationUserRolesArgs = {\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n  userId?: InputMaybe<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryPaginatedShareholdersArgs = {\n  excludeByIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  itemsPerPage: Scalars['Int']['input'];\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['Int']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryPortfolioHomeArgs = {\n  shareholder?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryQsbsTransactionsArgs = {\n  cutoffDate?: InputMaybe<Scalars['Date']['input']>;\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryRaiseOffersArgs = {\n  filterOffer?: InputMaybe<Scalars['UUID']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryRsuOfferArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryRsuOfferDetailsArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryRsuOfferGroupArgs = {\n  group: Scalars['RsuOfferGroupCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryRsuOfferListArgs = {\n  employee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryRsuOffersToCompleteArgs = {\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  organisationId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryRsuOffersVestingEventsArgs = {\n  offerIds: Array<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryRsuPlanOffersArgs = {\n  filterId: Scalars['UUID']['input'];\n  filters?: InputMaybe<Array<ListFilterType>>;\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']>>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryRsusArgs = {\n  filterPlan?: InputMaybe<Scalars['UUID']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QuerySbcOffersArgs = {\n  fromDate?: InputMaybe<Scalars['Date']['input']>;\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  toDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryScanbotDocumentArgs = {\n  scanbotDocument: Scalars['ScanbotDocumentCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryScanbotDocumentsArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QuerySentKudosArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareCertificateDisclaimerArgs = {\n  disclaimer: Scalars['ShareCertificateDisclaimerCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareCertificateDisclaimersListArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QuerySharePlanOffersArgs = {\n  filterId: Scalars['UUID']['input'];\n  filters?: InputMaybe<Array<ListFilterType>>;\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']>>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareTransferOfferArgs = {\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareTransferOffersArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n  transferRound: Scalars['ShareTransferRoundCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareTransferRoundsArgs = {\n  filterRound?: InputMaybe<Scalars['UUID']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholderAvailableSharesToTransferArgs = {\n  beneficiary?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  shareholder: Scalars['ShareholderCakeType']['input'];\n  sharetype: Scalars['SharetypeCakeType']['input'];\n  transferDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholderDocsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholderDocumentArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareholder?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholderNamesArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholderOffboardingOffersArgs = {\n  offboardingDate: Scalars['Date']['input'];\n  shareholder: Scalars['ShareholderCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholderTransactionsArgs = {\n  shareholderId?: InputMaybe<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersArgs = {\n  excludeByIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersCountArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersListArgs = {\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersOverviewArgs = {\n  diluted?: InputMaybe<Scalars['Boolean']['input']>;\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n  trust?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersReportArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  reportDate: Scalars['Date']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersSecuritiesBreakdownArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersToOffboardArgs = {\n  excludeByIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;\n  itemsPerPage: Scalars['Int']['input'];\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['Int']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersWithNoteholdingsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersWithOptionholdingsArgs = {\n  itemsPerPage: Scalars['Int']['input'];\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n  page: Scalars['Int']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersWithShareVestHoldingsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n  shareholderId?: InputMaybe<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersWithShareholdingsArgs = {\n  includeTrusts?: InputMaybe<Scalars['Boolean']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersWithSharesAtDateArgs = {\n  date?: InputMaybe<Scalars['Date']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShareholdersWithoutShareholdingsArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QuerySharetypesArgs = {\n  organisationId?: InputMaybe<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryShowSurveyArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryStakeholdersMergePreviewArgs = {\n  obsoleteShareholder: Scalars['ShareholderCakeType']['input'];\n  prevalentShareholder: Scalars['ShareholderCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryTemplateViewLinkArgs = {\n  contractType: Scalars['CleanString']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryTemplatesByContractTypeArgs = {\n  contractTypes: Array<Scalars['CleanString']['input']>;\n  country?: InputMaybe<Scalars['CleanString']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryTransactionDetailsArgs = {\n  transaction: Scalars['ShareholdingTransactionCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryUnusedTimeArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryUserOffersArgs = {\n  limit?: InputMaybe<Scalars['PositiveInteger']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryUserOrganisationsArgs = {\n  organisationIds?: InputMaybe<Array<Scalars['UUID']['input']>>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryUserOrganisationsSupportSearchArgs = {\n  userEmail?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryUserPreferenceArgs = {\n  default?: InputMaybe<Scalars['Boolean']['input']>;\n  name: Scalars['String']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryUserPreferencesArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryUserVestingOffersArgs = {\n  limit?: InputMaybe<Scalars['PositiveInteger']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryUsersWithMfaArgs = {\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisation?: InputMaybe<Scalars['OrganisationCakeType']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryVestingCliffArgs = {\n  eventId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryVestingScheduleTemplatesArgs = {\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page?: InputMaybe<Scalars['PositiveIntegerOrZero']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryWarrantDefaultPlanGroupArgs = {\n  organisation: Scalars['OrganisationCakeType']['input'];\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryWarrantOfferArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryWarrantOfferDetailsArgs = {\n  offerId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryWarrantOfferGroupArgs = {\n  group: Scalars['WarrantOfferGroupCakeType']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryWarrantOfferListArgs = {\n  employee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryWarrantOffersToCompleteArgs = {\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>>;\n  organisationId: Scalars['UUID']['input'];\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryWarrantOffersVestingEventsArgs = {\n  offerIds: Array<Scalars['UUID']['input']>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryWarrantPlanOffersArgs = {\n  filterId?: InputMaybe<Scalars['UUID']['input']>;\n  filters?: InputMaybe<Array<ListFilterType>>;\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']>>;\n};\n\n\n/** Defines schema available and resolve implementation in graphQL endpoint. */\nexport type QueryWarrantsArgs = {\n  filterPlan?: InputMaybe<Scalars['UUID']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n};\n\nexport type ReminderEmailType = {\n  __typename?: 'ReminderEmailType';\n  body?: Maybe<Scalars['String']['output']>;\n  recipientEmail?: Maybe<Scalars['String']['output']>;\n  recipientName?: Maybe<Scalars['String']['output']>;\n  subject?: Maybe<Scalars['String']['output']>;\n};\n\nexport type RemoveShareDocument = {\n  __typename?: 'RemoveShareDocument';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n *\n *     # This mutation deletes a document\n *\n *     mutation Example {\n *       renameDocument(\n *           documentId: \"34543505-7c7f-4127-bef8-a4d1bc3ce007\",\n *           newName: \"Document name number two\"\n *       ) {\n *             ok\n *         }\n *     }\n *\n */\nexport type RenameDocument = {\n  __typename?: 'RenameDocument';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     repayNote (\n *         noteId: \"00000000-0000-0000-0000-000000000000\",\n *     ) {\n *         ok\n *     }\n * }\n */\nexport type RepayNote = {\n  __typename?: 'RepayNote';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type ReportResponse = {\n  __typename?: 'ReportResponse';\n  optionholders?: Maybe<Array<Maybe<VestableholderReportEntry>>>;\n  rsuholders?: Maybe<Array<Maybe<VestableholderReportEntry>>>;\n  shareholders?: Maybe<Array<Maybe<ShareholderReportEntry>>>;\n  sharetypes?: Maybe<Array<Maybe<SharetypeReportEntry>>>;\n  unallocatedOptions?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  unallocatedRsus?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  unallocatedShares?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type RoleType = {\n  __typename?: 'RoleType';\n  name?: Maybe<Scalars['String']['output']>;\n  role?: Maybe<Scalars['String']['output']>;\n};\n\nexport type RoleWithDescription = {\n  __typename?: 'RoleWithDescription';\n  description?: Maybe<Scalars['String']['output']>;\n  role?: Maybe<Scalars['String']['output']>;\n};\n\n/** An enumeration. */\nexport enum RoundTypeEnum {\n  Both = 'BOTH',\n  Notes = 'NOTES',\n  Priced = 'PRICED'\n}\n\nexport type RsuConversionLockEventOutputType = {\n  __typename?: 'RsuConversionLockEventOutputType';\n  created: Scalars['DateTime']['output'];\n  /** The date the offer's conversion was unlocked */\n  date?: Maybe<Scalars['Date']['output']>;\n  description: Scalars['String']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  offer: RsuOfferOutputType;\n};\n\nexport type RsuOfferBulkEntryInputType = {\n  administrativeArea1?: InputMaybe<Scalars['String']['input']>;\n  administrativeArea2?: InputMaybe<Scalars['String']['input']>;\n  allowTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  autoGrant?: InputMaybe<Scalars['Boolean']['input']>;\n  conversionLockEvent?: InputMaybe<Scalars['CleanString']['input']>;\n  country?: InputMaybe<Scalars['String']['input']>;\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  grantDate?: InputMaybe<Scalars['Date']['input']>;\n  line1?: InputMaybe<Scalars['String']['input']>;\n  line2?: InputMaybe<Scalars['String']['input']>;\n  line3?: InputMaybe<Scalars['String']['input']>;\n  locality?: InputMaybe<Scalars['String']['input']>;\n  name: Scalars['CleanString']['input'];\n  postcode?: InputMaybe<Scalars['String']['input']>;\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n  vestingEvents: Array<InputMaybe<VestingEventInputType>>;\n};\n\nexport type RsuOfferGroupOutputType = {\n  __typename?: 'RsuOfferGroupOutputType';\n  /** Allow offer holders to nominate a trust */\n  allowNomineeTrust: Scalars['Boolean']['output'];\n  autoGenerated: Scalars['Boolean']['output'];\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  /** Default Offer Letter template used by this plan */\n  defaultOfferLetterTemplate?: Maybe<Document>;\n  /** Default Plan Rules template used by this plan */\n  defaultPlanRulesTemplate?: Maybe<Document>;\n  /** Disclosure period in days */\n  disclosurePeriodDays: Scalars['Int']['output'];\n  id: Scalars['UUID']['output'];\n  isEditable?: Maybe<Scalars['Boolean']['output']>;\n  modified: Scalars['DateTime']['output'];\n  offerAcceptedCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  offerCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Offer Letter template used by this RSU */\n  offerLetterTemplate: Array<Document>;\n  /** RSU this group belongs to */\n  plan: RsuOutputType;\n  /** Plan Rules template used by this RSU */\n  planRulesTemplate: Array<Document>;\n  /** Require board approval before sending offers */\n  requireBoardApproval: Scalars['Boolean']['output'];\n  /** Offer common fields */\n  rsuofferSet: Array<RsuOfferOutputType>;\n  sharetype?: Maybe<Sharetype>;\n  totalExercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalGranted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalLapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalOffered?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalVested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type RsuOfferInputType = {\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  bareTrustTrustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  conversionLockEvent?: InputMaybe<Scalars['CleanString']['input']>;\n  emailsOn?: InputMaybe<Scalars['Boolean']['input']>;\n  grantDate?: InputMaybe<Scalars['Date']['input']>;\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n  vestingEvents: Array<InputMaybe<VestingEventInputType>>;\n};\n\nexport type RsuOfferOutputType = {\n  __typename?: 'RsuOfferOutputType';\n  /** Allow option holders to nominate a trust */\n  allowNomineeTrust: Scalars['Boolean']['output'];\n  /** Whether options lapse on termination */\n  autoLapseOnTermination: Scalars['Boolean']['output'];\n  availableToExercise?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToLapse?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToPeriodicVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVestMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Investor/employee share holding entity */\n  bareTrustTrustee?: Maybe<Shareholder>;\n  boardApproval?: Maybe<BoardApprovalType>;\n  calendar?: Maybe<OfferCalendarOutputType>;\n  conversionLockDate?: Maybe<Scalars['Date']['output']>;\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  currency?: Maybe<Scalars['String']['output']>;\n  dateGranted?: Maybe<Scalars['Date']['output']>;\n  /** Disclosure period in days */\n  disclosurePeriodDays: Scalars['Int']['output'];\n  /** True means sending regular vesting emails to investor */\n  emailsOn: Scalars['Boolean']['output'];\n  exercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** The day the offer is granted (override) */\n  grantDateDefault?: Maybe<Scalars['Date']['output']>;\n  granted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Offer common fields */\n  group: RsuOfferGroupOutputType;\n  hasOngoingPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasScheduledPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasTransactions?: Maybe<Scalars['Boolean']['output']>;\n  id: Scalars['UUID']['output'];\n  /** The date the offer moved to READY_TO_CONFIRM_DETAILS */\n  inviteDate?: Maybe<Scalars['Date']['output']>;\n  lapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsedMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsedPeriodic?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lastEventDate?: Maybe<Scalars['Date']['output']>;\n  lastRepricingDate?: Maybe<Scalars['Date']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** The next vesting date computed daily by the calendar calculator */\n  nextVestingDate?: Maybe<Scalars['Date']['output']>;\n  /** The next vesting meta computed daily by the calendar calculator */\n  nextVestingMeta?: Maybe<RsuRsuOfferNextVestingMetaChoices>;\n  /** Offboarding settings for this offer */\n  offboardSettings?: Maybe<OffboardEventSettingsOutputType>;\n  /** Signer Offer Letter for this RSU offer */\n  offerLetter?: Maybe<Document>;\n  offerLetterOpt?: Maybe<Document>;\n  /** Template to generate the offer letter from */\n  offerLetterTemplate?: Maybe<Document>;\n  pauseEvents?: Maybe<Array<Maybe<RsuOfferPauseEventOutputType>>>;\n  plan?: Maybe<RsuOutputType>;\n  /** Plan Rules for this RSU */\n  planRules?: Maybe<Document>;\n  /** Template to generate the Plan Rules from, or final doc */\n  planRulesTemplate?: Maybe<Document>;\n  /** Makes it a requirement that a witness also needs to sign the offer letter. */\n  requireWitness: Scalars['Boolean']['output'];\n  rsuconversionlockevent?: Maybe<RsuConversionLockEventOutputType>;\n  rsuofferpauseeventSet: Array<RsuOfferPauseEventOutputType>;\n  /** RSU offer */\n  rsutransactionSet: Array<RsuTransactionOutputType>;\n  /** RSU offer */\n  rsuvestingeventSet: Array<RsuVestingEventOutputType>;\n  /** Investor/employee holder entity */\n  shareholder: Shareholder;\n  shareholderDisplayName?: Maybe<Scalars['String']['output']>;\n  shareholderOpt?: Maybe<Shareholder>;\n  sharetype?: Maybe<Sharetype>;\n  softStatus?: Maybe<Scalars['String']['output']>;\n  status?: Maybe<Scalars['String']['output']>;\n  totalCliffDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalGranted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalPeriodicDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestStartDate?: Maybe<Scalars['Date']['output']>;\n  vestableMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestablePeriodic?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestedMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestingEvents?: Maybe<Array<Maybe<RsuVestingEventOutputType>>>;\n};\n\nexport type RsuOfferPauseEventOutputType = {\n  __typename?: 'RsuOfferPauseEventOutputType';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  offer: RsuOfferOutputType;\n  /** Date when vest pause starts */\n  pauseDate: Scalars['Date']['output'];\n  /** Date when vest pause ends */\n  resumeDate: Scalars['Date']['output'];\n  status?: Maybe<Scalars['String']['output']>;\n};\n\nexport type RsuOutputType = {\n  __typename?: 'RsuOutputType';\n  autoGenerated: Scalars['Boolean']['output'];\n  cakegroupSet: Array<CakeGroupType>;\n  commentCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  created: Scalars['DateTime']['output'];\n  documents?: Maybe<Array<Maybe<Document>>>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** Name of this vesting plan */\n  name?: Maybe<Scalars['String']['output']>;\n  offerCount?: Maybe<Scalars['Int']['output']>;\n  offerGroup?: Maybe<Array<Maybe<RsuOfferGroupOutputType>>>;\n  /** Organisation this plan belongs to */\n  organisation: Organisation;\n  percentageOfOrganisationShares?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Makes it a requirement that a witness also needs to sign the offer letter. */\n  requireWitness: Scalars['Boolean']['output'];\n  /** RSU this group belongs to */\n  rsuoffergroupSet: Array<RsuOfferGroupOutputType>;\n  totalExercised?: Maybe<Scalars['BigInt']['output']>;\n  totalGranted?: Maybe<Scalars['BigInt']['output']>;\n  totalLapsed?: Maybe<Scalars['BigInt']['output']>;\n  totalOffered?: Maybe<Scalars['BigInt']['output']>;\n  totalVested?: Maybe<Scalars['BigInt']['output']>;\n  vestingValue?: Maybe<Scalars['BigInt']['output']>;\n};\n\n/** An enumeration. */\nexport enum RsuRsuOfferNextVestingMetaChoices {\n  /** Fully vesting */\n  FullyVesting = 'FULLY_VESTING',\n  /** Meeting milestone */\n  MeetingMilestone = 'MEETING_MILESTONE',\n  /** Periodic vesting */\n  PeriodicVesting = 'PERIODIC_VESTING',\n  /** Reaching cliff */\n  ReachingCliff = 'REACHING_CLIFF',\n  /** Unknown */\n  Unknown = 'UNKNOWN'\n}\n\n/** An enumeration. */\nexport enum RsuRsuTransactionTypeChoices {\n  /** EXERCISED */\n  Exercised = 'EXERCISED',\n  /** GRANTED */\n  Granted = 'GRANTED',\n  /** LAPSED */\n  Lapsed = 'LAPSED',\n  /** REPRICED */\n  Repriced = 'REPRICED',\n  /** VESTED */\n  Vested = 'VESTED'\n}\n\nexport type RsuTransactionOutputType = {\n  __typename?: 'RsuTransactionOutputType';\n  /** True if this transaction is accelerated */\n  accelerated: Scalars['Boolean']['output'];\n  /** Document relevant for this transaction (eg: Option repricing board approval) */\n  attachment?: Maybe<Document>;\n  commentCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  /** True is manually inserted, False if it comes from the auto-vest algo */\n  isManual: Scalars['Boolean']['output'];\n  lastComment?: Maybe<Scalars['String']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** RSU offer */\n  offer: RsuOfferOutputType;\n  planName?: Maybe<Scalars['String']['output']>;\n  /** Share transaction associated with this vesting transaction */\n  shareTransaction?: Maybe<ShareholdingTransaction>;\n  sharetype?: Maybe<Sharetype>;\n  /** Transaction date */\n  transactionDate: Scalars['Date']['output'];\n  /** Transaction type (eg. vested, exercised, lapsed */\n  type: RsuRsuTransactionTypeChoices;\n  /** Offer Vesting Event */\n  vestingEvent?: Maybe<RsuVestingEventOutputType>;\n  vestingValue?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type RsuVestingEventOutputType = {\n  __typename?: 'RsuVestingEventOutputType';\n  created: Scalars['DateTime']['output'];\n  eventType?: Maybe<Scalars['String']['output']>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** RSU offer */\n  offer: RsuOfferOutputType;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  /** Event order */\n  order: Scalars['Int']['output'];\n  /** Offer Vesting Event */\n  rsutransactionSet: Array<RsuTransactionOutputType>;\n  vestingData?: Maybe<VestingDataOutputType>;\n  /** Amount offered to investor/employee in this event */\n  vestingValue: Scalars['BigInt']['output'];\n};\n\n/** An enumeration. */\nexport enum SalesLicenseCakePlanChoices {\n  /** CSFGROWTH_5_M_5 */\n  Csfgrowth_5M_5 = 'CSFGROWTH_5_M_5',\n  /** CSFGROWTH_5_Q_5 */\n  Csfgrowth_5Q_5 = 'CSFGROWTH_5_Q_5',\n  /** CSFGROWTH_5_Y_5 */\n  Csfgrowth_5Y_5 = 'CSFGROWTH_5_Y_5',\n  /** CSFPRO_5_M_5 */\n  Csfpro_5M_5 = 'CSFPRO_5_M_5',\n  /** CSFPRO_5_Q_5 */\n  Csfpro_5Q_5 = 'CSFPRO_5_Q_5',\n  /** CSFPRO_5_Y_5 */\n  Csfpro_5Y_5 = 'CSFPRO_5_Y_5',\n  /** CSFSTARTER_5_M_5 */\n  Csfstarter_5M_5 = 'CSFSTARTER_5_M_5',\n  /** CSFSTARTER_5_Q_5 */\n  Csfstarter_5Q_5 = 'CSFSTARTER_5_Q_5',\n  /** CSFSTARTER_5_Y_5 */\n  Csfstarter_5Y_5 = 'CSFSTARTER_5_Y_5',\n  /** FREE_0_M */\n  Free_0M = 'FREE_0_M',\n  /** GLOBAL_5_M */\n  Global_5M = 'GLOBAL_5_M',\n  /** GLOBAL_5_Y */\n  Global_5Y = 'GLOBAL_5_Y',\n  /** GROWTH_2_M */\n  Growth_2M = 'GROWTH_2_M',\n  /** GROWTH_2_Y */\n  Growth_2Y = 'GROWTH_2_Y',\n  /** GROWTH_3_M */\n  Growth_3M = 'GROWTH_3_M',\n  /** GROWTH_3_Y */\n  Growth_3Y = 'GROWTH_3_Y',\n  /** GROWTH_4_M */\n  Growth_4M = 'GROWTH_4_M',\n  /** GROWTH_4_Y */\n  Growth_4Y = 'GROWTH_4_Y',\n  /** GROWTH_5_M */\n  Growth_5M = 'GROWTH_5_M',\n  /** GROWTH_5_M_5 */\n  Growth_5M_5 = 'GROWTH_5_M_5',\n  /** GROWTH_5_Q_5 */\n  Growth_5Q_5 = 'GROWTH_5_Q_5',\n  /** GROWTH_5_Y */\n  Growth_5Y = 'GROWTH_5_Y',\n  /** GROWTH_5_Y_5 */\n  Growth_5Y_5 = 'GROWTH_5_Y_5',\n  /** PRO_5_M_5 */\n  Pro_5M_5 = 'PRO_5_M_5',\n  /** PRO_5_Q_5 */\n  Pro_5Q_5 = 'PRO_5_Q_5',\n  /** PRO_5_Y_5 */\n  Pro_5Y_5 = 'PRO_5_Y_5',\n  /** STARTER_2_M */\n  Starter_2M = 'STARTER_2_M',\n  /** STARTER_2_Y */\n  Starter_2Y = 'STARTER_2_Y',\n  /** STARTER_3_M */\n  Starter_3M = 'STARTER_3_M',\n  /** STARTER_3_Y */\n  Starter_3Y = 'STARTER_3_Y',\n  /** STARTER_4_M */\n  Starter_4M = 'STARTER_4_M',\n  /** STARTER_4_Y */\n  Starter_4Y = 'STARTER_4_Y',\n  /** STARTER_5_M */\n  Starter_5M = 'STARTER_5_M',\n  /** STARTER_5_M_5 */\n  Starter_5M_5 = 'STARTER_5_M_5',\n  /** STARTER_5_Q_5 */\n  Starter_5Q_5 = 'STARTER_5_Q_5',\n  /** STARTER_5_Y */\n  Starter_5Y = 'STARTER_5_Y',\n  /** STARTER_5_Y_5 */\n  Starter_5Y_5 = 'STARTER_5_Y_5'\n}\n\nexport type ScanbotDocumentType = {\n  __typename?: 'ScanbotDocumentType';\n  created: Scalars['DateTime']['output'];\n  /** The contract under analysis */\n  document: Document;\n  /** An editable version of the contract */\n  editableDocument?: Maybe<Document>;\n  id: Scalars['UUID']['output'];\n  result?: Maybe<Scalars['GenericScalar']['output']>;\n  status: DocumentsScanbotDocumentStatusChoices;\n};\n\n/** An enumeration. */\nexport enum SeCakeGroupGroupTypeChoices {\n  /** ESOP */\n  Esop = 'ESOP',\n  /** ESS */\n  Ess = 'ESS',\n  /** MANUAL */\n  Manual = 'MANUAL',\n  /** NOTEHOLDER */\n  Noteholder = 'NOTEHOLDER',\n  /** NOTESROUNDS */\n  Notesrounds = 'NOTESROUNDS',\n  /** OFFICEHOLDER */\n  Officeholder = 'OFFICEHOLDER',\n  /** OPTIONHOLDER */\n  Optionholder = 'OPTIONHOLDER',\n  /** ORGANISATION */\n  Organisation = 'ORGANISATION',\n  /** RAISE */\n  Raise = 'RAISE',\n  /** RSU */\n  Rsu = 'RSU',\n  /** SHAREHOLDER */\n  Shareholder = 'SHAREHOLDER',\n  /** SHARETRANSFERROUNDS */\n  Sharetransferrounds = 'SHARETRANSFERROUNDS',\n  /** SHARETYPE */\n  Sharetype = 'SHARETYPE',\n  /** WARRANT */\n  Warrant = 'WARRANT'\n}\n\n/** An enumeration. */\nexport enum SeEmailSenderEntryTypeChoices {\n  /** Transaction Digest Entry */\n  Digest = 'DIGEST',\n  /** Digest Email Sender */\n  DigestSend = 'DIGEST_SEND',\n  /** Invite Email */\n  Invite = 'INVITE',\n  /** Onboarding complete */\n  Onboarding = 'ONBOARDING'\n}\n\n/** An enumeration. */\nexport enum SeEmployeeDataLevelChoices {\n  /** Advisor */\n  Advisor = 'ADVISOR',\n  /** CEO */\n  Ceo = 'CEO',\n  /** Executive */\n  Executive = 'EXECUTIVE',\n  /** Junior */\n  Junior = 'JUNIOR',\n  /** Mid-level */\n  MidLevel = 'MID_LEVEL',\n  /** Senior */\n  Senior = 'SENIOR'\n}\n\n/** An enumeration. */\nexport enum SeEmployeeDataRoleChoices {\n  /** CEO */\n  Ceo = 'CEO',\n  /** Customer success */\n  CustomerSuccess = 'CUSTOMER_SUCCESS',\n  /** Data */\n  Data = 'DATA',\n  /** Design */\n  Design = 'DESIGN',\n  /** Engineering */\n  Engineering = 'ENGINEERING',\n  /** Finance */\n  Finance = 'FINANCE',\n  /** Founder */\n  Founder = 'FOUNDER',\n  /** Marketing/Growth */\n  MarketingGrowth = 'MARKETING_GROWTH',\n  /** Product */\n  Product = 'PRODUCT',\n  /** Sales/BD */\n  SalesBd = 'SALES_BD',\n  /** Strategy/Operations */\n  StrategyOperations = 'STRATEGY_OPERATIONS',\n  /** Talent/People */\n  TalentPeople = 'TALENT_PEOPLE'\n}\n\n/** An enumeration. */\nexport enum SeOffboardEventSettingsStopVestingAtChoices {\n  /** AFTER_PTEP */\n  AfterPtep = 'AFTER_PTEP',\n  /** NONE */\n  None = 'NONE',\n  /** OFFBOARD_DATE */\n  OffboardDate = 'OFFBOARD_DATE'\n}\n\n/** An enumeration. */\nexport enum SeOfficeholderRoleRoleChoices {\n  /** Alternate */\n  Alt = 'ALT',\n  /** Director */\n  Dir = 'DIR',\n  /** Officer/Authorised Person */\n  Ofc = 'OFC',\n  /** President */\n  Prs = 'PRS',\n  /** Secretary */\n  Sec = 'SEC'\n}\n\n/** An enumeration. */\nexport enum SeOfficeholderSignerChoices {\n  /** Primary Signer */\n  Primary = 'PRIMARY',\n  /** Secondary Signer */\n  Secondary = 'SECONDARY'\n}\n\n/** An enumeration. */\nexport enum SeOrganisationRaiseOfferStatusChoices {\n  /** Investor refused the offer */\n  Declined = 'DECLINED',\n  /** Waiting for Investor to accept and confirm investment amount */\n  ReadyToAccept = 'READY_TO_ACCEPT',\n  /** Waiting for Investor to confirm Details */\n  ReadyToConfirmDetails = 'READY_TO_CONFIRM_DETAILS',\n  /** Waiting for Officeholder to Issue Shares */\n  ReadyToIssue = 'READY_TO_ISSUE',\n  /** Waiting for Investor to pay */\n  ReadyToPay = 'READY_TO_PAY',\n  /** Waiting for Investor Signatures */\n  ReadyToSign = 'READY_TO_SIGN',\n  /** Waiting for Officeholder to send Invitation */\n  ReadyToStart = 'READY_TO_START',\n  /** Offer concluded */\n  SharesIssued = 'SHARES_ISSUED'\n}\n\n/** An enumeration. */\nexport enum SeShareholdingTransactionTypeChoices {\n  /** BUY_BACK */\n  BuyBack = 'BUY_BACK',\n  /** CONVERSION */\n  Conversion = 'CONVERSION',\n  /** IMPORT */\n  Import = 'IMPORT',\n  /** ISSUE */\n  Issue = 'ISSUE',\n  /** SHARE_SPLIT */\n  ShareSplit = 'SHARE_SPLIT',\n  /** SHARE_SPLIT_COMPLETE */\n  ShareSplitComplete = 'SHARE_SPLIT_COMPLETE',\n  /** TRANSFER */\n  Transfer = 'TRANSFER'\n}\n\nexport type SendMessageOutputType = {\n  __typename?: 'SendMessageOutputType';\n  messageId?: Maybe<Scalars['UUID']['output']>;\n  replyThreadId?: Maybe<Scalars['UUID']['output']>;\n};\n\nexport type SendTestTransactionalEmail = {\n  __typename?: 'SendTestTransactionalEmail';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type SentKudosType = {\n  __typename?: 'SentKudosType';\n  actionType?: Maybe<Scalars['String']['output']>;\n  badge?: Maybe<Scalars['String']['output']>;\n  context?: Maybe<Scalars['String']['output']>;\n  displayName?: Maybe<Scalars['String']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  message?: Maybe<Scalars['String']['output']>;\n};\n\n/**\n * # Skip the invite flow for offers tracked off-platform or adding historical data.\n * mutation {\n *     settleEquityOfferOffline (\n *         offer: \"00000000-0000-0000-0000-000000000000\",\n *         contract: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type SettleEquityOfferOffline = {\n  __typename?: 'SettleEquityOfferOffline';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type SettleExerciseRequestOffline = {\n  __typename?: 'SettleExerciseRequestOffline';\n  exerciseTransaction?: Maybe<ExerciseTransactionDataType>;\n};\n\n/**\n * # Skip the invite flow for offers tracked off-platform or adding historical data.\n * mutation {\n *     settleNotesOfferOffline (\n *         offer: \"00000000-0000-0000-0000-000000000000\",\n *         principal: 10,\n *         contract: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type SettleNotesOfferOffline = {\n  __typename?: 'SettleNotesOfferOffline';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type SettleShareTransferOfferOffline = {\n  __typename?: 'SettleShareTransferOfferOffline';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type SgCompanyDetailsField = {\n  __typename?: 'SgCompanyDetailsField';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  registeredAddress?: Maybe<InternationalAddressField>;\n  uen?: Maybe<Scalars['String']['output']>;\n};\n\nexport type SgCompanyDetailsInput = {\n  registeredAddress?: InputMaybe<AddressInput>;\n  uen: Scalars['CleanString']['input'];\n};\n\nexport type SgPaymentDetailsType = {\n  __typename?: 'SgPaymentDetailsType';\n  accountName?: Maybe<Scalars['String']['output']>;\n  accountNumber?: Maybe<Scalars['String']['output']>;\n  bankCode?: Maybe<Scalars['String']['output']>;\n  branchCode?: Maybe<Scalars['String']['output']>;\n  swiftCode?: Maybe<Scalars['String']['output']>;\n};\n\nexport type ShareCertificateDisclaimerType = {\n  __typename?: 'ShareCertificateDisclaimerType';\n  created: Scalars['DateTime']['output'];\n  disclaimerText: Scalars['String']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  name: Scalars['String']['output'];\n  organisation: Organisation;\n  sharetypeDefault?: Maybe<Sharetype>;\n};\n\nexport type ShareDocument = {\n  __typename?: 'ShareDocument';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type ShareSplitDetailType = {\n  __typename?: 'ShareSplitDetailType';\n  remainder: Scalars['Int']['output'];\n  shareholderId: Scalars['UUID']['output'];\n  shareholderName: Scalars['String']['output'];\n  shares: Scalars['Int']['output'];\n};\n\nexport type ShareTransferOfferType = {\n  __typename?: 'ShareTransferOfferType';\n  amount?: Maybe<Scalars['CakeDecimal']['output']>;\n  created: Scalars['DateTime']['output'];\n  fromShareholder: Shareholder;\n  fromShareholderConfirmed?: Maybe<Scalars['Boolean']['output']>;\n  id: Scalars['UUID']['output'];\n  isSeller?: Maybe<Scalars['Boolean']['output']>;\n  metadata?: Maybe<Scalars['JSONString']['output']>;\n  modified: Scalars['DateTime']['output'];\n  offlineContract?: Maybe<Document>;\n  paid?: Maybe<Scalars['CakeDecimal']['output']>;\n  shareTransferAgreementContract?: Maybe<Document>;\n  shareTransferRound: ShareTransferRoundType;\n  shares: Scalars['BigInt']['output'];\n  sharetype: Sharetype;\n  status: TransfersShareTransferOfferStatusChoices;\n  toShareholder: Shareholder;\n  toShareholderConfirmed?: Maybe<Scalars['Boolean']['output']>;\n  transactionFrom?: Maybe<ShareholdingTransaction>;\n  transactionTo?: Maybe<ShareholdingTransaction>;\n};\n\nexport type ShareTransferRoundType = {\n  __typename?: 'ShareTransferRoundType';\n  cakegroupSet: Array<CakeGroupType>;\n  created: Scalars['DateTime']['output'];\n  documents?: Maybe<Array<Maybe<Document>>>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  name: Scalars['String']['output'];\n  offerCount?: Maybe<Scalars['Int']['output']>;\n  organisation: Organisation;\n  shareTransferAgreementTemplate?: Maybe<Document>;\n  sharetransferofferSet: Array<ShareTransferOfferType>;\n};\n\nexport type ShareTypeInput = {\n  authorisedShares?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  dividend?: InputMaybe<Scalars['Boolean']['input']>;\n  name: Scalars['CleanString']['input'];\n  symbol: Scalars['CleanString']['input'];\n  voting?: InputMaybe<Scalars['Boolean']['input']>;\n  weight?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\n/**\n *\n *     # The profile for a Shareholder.\n *     # Querying it lists Shareholders for a given organisationId.\n *\n *     query Example {shareholders\n *         (organisationId: \"604ad5d1-c44f-44b2-abb4-7877d96ed188\") {\n *                 id\n *                 name\n *             }\n *         }\n *\n */\nexport type Shareholder = {\n  __typename?: 'Shareholder';\n  avatar?: Maybe<Scalars['String']['output']>;\n  bareTrust: Array<OptionExerciseRequestType>;\n  beneficiaryShareholdings?: Maybe<Array<Maybe<ShareholdingType>>>;\n  cakeReplyThreadParticipantShareholders: Array<CakeReplyThreadType>;\n  cakegroupSet: Array<CakeGroupType>;\n  comments?: Maybe<Scalars['String']['output']>;\n  computedType?: Maybe<Scalars['String']['output']>;\n  consideredInvited?: Maybe<Scalars['Boolean']['output']>;\n  consideredInvitedBecauseOffersSent?: Maybe<Scalars['Boolean']['output']>;\n  created: Scalars['DateTime']['output'];\n  displayName?: Maybe<Scalars['String']['output']>;\n  documents?: Maybe<Array<Maybe<Document>>>;\n  employeeData?: Maybe<EmployeeDataType>;\n  employeedataSet: Array<EmployeeDataType>;\n  /** Investor/employee holder entity */\n  esopofferSet: Array<EsopOffer>;\n  /** Investor/employee holder entity */\n  essofferSet: Array<EssOffer>;\n  /** Investor/employee holder entity */\n  foundervestingofferSet: Array<FounderVestingOfferOutputType>;\n  groupSharedDocumentsCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  groupedBeneficiariesShareholdings?: Maybe<Array<Maybe<GroupedShareholdingInTrustType>>>;\n  groupedFounderVestingHoldings?: Maybe<Array<Maybe<GroupedFounderVestHoldingType>>>;\n  groupedNoteholdings?: Maybe<Array<Maybe<GroupedNoteholdingType>>>;\n  groupedOptionholdings?: Maybe<Array<Maybe<GroupedOptionholdingType>>>;\n  groupedRsuHoldings?: Maybe<Array<Maybe<GroupedRsuHoldingType>>>;\n  groupedShareVestHoldings?: Maybe<Array<Maybe<GroupedShareVestHoldingType>>>;\n  groupedShareholdings?: Maybe<Array<Maybe<GroupedShareholdingType>>>;\n  groupedShareholdingsInTrust?: Maybe<Array<Maybe<GroupedShareholdingInTrustType>>>;\n  groupedTrusteesShareholdings?: Maybe<Array<Maybe<GroupedShareholdingInTrustType>>>;\n  groupedWarrantHoldings?: Maybe<Array<Maybe<GroupedWarrantHoldingType>>>;\n  hasBeenInvited?: Maybe<Scalars['Boolean']['output']>;\n  hasInvite?: Maybe<Scalars['Boolean']['output']>;\n  hasLoggedIn?: Maybe<Scalars['Boolean']['output']>;\n  heldInTrust?: Maybe<Scalars['Boolean']['output']>;\n  id: Scalars['UUID']['output'];\n  /** Employee ID or similar */\n  identificationCode?: Maybe<Scalars['String']['output']>;\n  investorData?: Maybe<Array<Maybe<InvestorDataType>>>;\n  investordataSet: Array<InvestorDataType>;\n  investorholdingSet: Array<GroupedShareholdingType>;\n  investortrustholdingBenificiary: Array<GroupedShareholdingInTrustType>;\n  inviteLink?: Maybe<Scalars['String']['output']>;\n  isGeneratingCertificate?: Maybe<Scalars['Boolean']['output']>;\n  lastShareCertificate?: Maybe<Document>;\n  messagesCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** Noteholder */\n  noteSet: Array<Note>;\n  noteholdings?: Maybe<Array<Maybe<NoteTransaction>>>;\n  notes?: Maybe<Array<Maybe<Note>>>;\n  /** Future Noteholder */\n  notesroundofferSet: Array<NotesRoundOfferType>;\n  offboardingSet: Array<OffboardingOutputType>;\n  optionholdings?: Maybe<Array<Maybe<EsopTransaction>>>;\n  organisation: Organisation;\n  /** Potential Investor */\n  organisationraiseofferSet: Array<OrganisationRaiseOffer>;\n  primaryEmail?: Maybe<Scalars['String']['output']>;\n  recipient?: Maybe<Shareholder>;\n  rsuholdings?: Maybe<Array<Maybe<RsuTransactionOutputType>>>;\n  /** Investor/employee holder entity */\n  rsuofferSet: Array<RsuOfferOutputType>;\n  secondaryName?: Maybe<Scalars['String']['output']>;\n  shareVestHoldings?: Maybe<Array<Maybe<EssTransaction>>>;\n  sharedDocumentsCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  shareholdings?: Maybe<Array<Maybe<ShareholdingType>>>;\n  shareholdingtransactionSet: Array<ShareholdingTransaction>;\n  sharetransferofferFrom: Array<ShareTransferOfferType>;\n  sharetransferofferTo: Array<ShareTransferOfferType>;\n  /** is shareholder a wholesale investor */\n  sophisticatedInvestor?: Maybe<Scalars['Boolean']['output']>;\n  totalConvertibleNotesInvestment?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalPaidInIssuance?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalRsus?: Maybe<Scalars['BigInt']['output']>;\n  totalSafeNotesInvestment?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalUnvestedOptions?: Maybe<Scalars['BigInt']['output']>;\n  totalVestedOptions?: Maybe<Scalars['BigInt']['output']>;\n  transactionsInTrust: Array<ShareholdingTransaction>;\n  trust?: Maybe<TrustType>;\n  trustAbn?: Maybe<Scalars['String']['output']>;\n  trustInfo?: Maybe<Scalars['JSONString']['output']>;\n  trustName?: Maybe<Scalars['String']['output']>;\n  user: Array<UserType>;\n  warrantholdings?: Maybe<Array<Maybe<WarrantTransactionOutputType>>>;\n  /** Investor/employee holder entity */\n  warrantofferSet: Array<WarrantOfferOutputType>;\n};\n\n\n/**\n *\n *     # The profile for a Shareholder.\n *     # Querying it lists Shareholders for a given organisationId.\n *\n *     query Example {shareholders\n *         (organisationId: \"604ad5d1-c44f-44b2-abb4-7877d96ed188\") {\n *                 id\n *                 name\n *             }\n *         }\n *\n */\nexport type ShareholderGroupedNoteholdingsArgs = {\n  excludeResolved?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/**\n *\n *     # The profile for a Shareholder.\n *     # Querying it lists Shareholders for a given organisationId.\n *\n *     query Example {shareholders\n *         (organisationId: \"604ad5d1-c44f-44b2-abb4-7877d96ed188\") {\n *                 id\n *                 name\n *             }\n *         }\n *\n */\nexport type ShareholderGroupedOptionholdingsArgs = {\n  grantedOnly?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/**\n *\n *     # The profile for a Shareholder.\n *     # Querying it lists Shareholders for a given organisationId.\n *\n *     query Example {shareholders\n *         (organisationId: \"604ad5d1-c44f-44b2-abb4-7877d96ed188\") {\n *                 id\n *                 name\n *             }\n *         }\n *\n */\nexport type ShareholderGroupedRsuHoldingsArgs = {\n  grantedOnly?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/**\n *\n *     # The profile for a Shareholder.\n *     # Querying it lists Shareholders for a given organisationId.\n *\n *     query Example {shareholders\n *         (organisationId: \"604ad5d1-c44f-44b2-abb4-7877d96ed188\") {\n *                 id\n *                 name\n *             }\n *         }\n *\n */\nexport type ShareholderOptionholdingsArgs = {\n  includeLastComment?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/**\n *\n *     # The profile for a Shareholder.\n *     # Querying it lists Shareholders for a given organisationId.\n *\n *     query Example {shareholders\n *         (organisationId: \"604ad5d1-c44f-44b2-abb4-7877d96ed188\") {\n *                 id\n *                 name\n *             }\n *         }\n *\n */\nexport type ShareholderRsuholdingsArgs = {\n  includeLastComment?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/**\n *\n *     # The profile for a Shareholder.\n *     # Querying it lists Shareholders for a given organisationId.\n *\n *     query Example {shareholders\n *         (organisationId: \"604ad5d1-c44f-44b2-abb4-7877d96ed188\") {\n *                 id\n *                 name\n *             }\n *         }\n *\n */\nexport type ShareholderShareholdingsArgs = {\n  includeBeneficiary?: InputMaybe<Scalars['Boolean']['input']>;\n  includeLastComment?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\n\n/**\n *\n *     # The profile for a Shareholder.\n *     # Querying it lists Shareholders for a given organisationId.\n *\n *     query Example {shareholders\n *         (organisationId: \"604ad5d1-c44f-44b2-abb4-7877d96ed188\") {\n *                 id\n *                 name\n *             }\n *         }\n *\n */\nexport type ShareholderWarrantholdingsArgs = {\n  includeLastComment?: InputMaybe<Scalars['Boolean']['input']>;\n};\n\nexport type ShareholderDataInput = {\n  bareTrust?: InputMaybe<BareTrustInput>;\n  comments?: InputMaybe<Scalars['CleanString']['input']>;\n  companyInfo?: InputMaybe<CompanyInvestorDataInput>;\n  employeeData?: InputMaybe<EmployeeDataInput>;\n  identificationCode?: InputMaybe<Scalars['CleanString']['input']>;\n  investors: Array<InputMaybe<InvestorDataInput>>;\n  trustInfo?: InputMaybe<ShareholderTrustInfoInput>;\n  trustName?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\nexport type ShareholderEmployeeInput = {\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  employeeData?: InputMaybe<EmployeeDataInput>;\n  id: Scalars['UUID']['input'];\n};\n\nexport type ShareholderExistingTransactions = {\n  __typename?: 'ShareholderExistingTransactions';\n  name?: Maybe<Scalars['String']['output']>;\n  reason?: Maybe<Scalars['String']['output']>;\n};\n\nexport type ShareholderHoldingsReportEntry = {\n  __typename?: 'ShareholderHoldingsReportEntry';\n  shares?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  sharetype?: Maybe<Scalars['UUID']['output']>;\n  unvestedShares?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type ShareholderIssueSharesInput = {\n  advanced?: InputMaybe<ShareholderIssueSharesTransactionInput>;\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  id?: InputMaybe<Scalars['UUID']['input']>;\n  name: Scalars['CleanString']['input'];\n  shares: Scalars['PositiveInteger']['input'];\n};\n\nexport type ShareholderIssueSharesTransactionInput = {\n  issueDate: Scalars['Date']['input'];\n  paid?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  sharetype: Scalars['SharetypeCakeType']['input'];\n};\n\nexport type ShareholderOffboardingOffersOutputType = {\n  __typename?: 'ShareholderOffboardingOffersOutputType';\n  esopOffers?: Maybe<Array<Maybe<EsopOffer>>>;\n  essOffers?: Maybe<Array<Maybe<EssOffer>>>;\n  founderVestingOffers?: Maybe<Array<Maybe<FounderVestingOfferOutputType>>>;\n  rsuOffers?: Maybe<Array<Maybe<RsuOfferOutputType>>>;\n  shareholder?: Maybe<Shareholder>;\n};\n\nexport type ShareholderOwnership = {\n  __typename?: 'ShareholderOwnership';\n  avatar?: Maybe<Scalars['String']['output']>;\n  name?: Maybe<Scalars['String']['output']>;\n  number?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  sid?: Maybe<Scalars['UUID']['output']>;\n};\n\nexport type ShareholderReportEntry = {\n  __typename?: 'ShareholderReportEntry';\n  displayName?: Maybe<Scalars['CleanString']['output']>;\n  holdings?: Maybe<Array<Maybe<ShareholderHoldingsReportEntry>>>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  shares?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type ShareholderTrustInfoInput = {\n  heldInTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  trustAbn?: InputMaybe<Scalars['CleanString']['input']>;\n  trustName?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\nexport type ShareholderWithVestableHoldingsType = {\n  __typename?: 'ShareholderWithVestableHoldingsType';\n  avatar?: Maybe<Scalars['String']['output']>;\n  consideredInvited?: Maybe<Scalars['Boolean']['output']>;\n  displayName?: Maybe<Scalars['String']['output']>;\n  email?: Maybe<Scalars['String']['output']>;\n  groupedVestableHoldings?: Maybe<Array<Maybe<VestableHoldingType>>>;\n  hasLoggedIn?: Maybe<Scalars['Boolean']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  isTrust?: Maybe<Scalars['Boolean']['output']>;\n  secondaryName?: Maybe<Scalars['String']['output']>;\n  stakeholderType?: Maybe<Scalars['String']['output']>;\n};\n\nexport type ShareholdersDeleteAttempt = {\n  __typename?: 'ShareholdersDeleteAttempt';\n  deletionCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  existingTransactions?: Maybe<Array<Maybe<ShareholderExistingTransactions>>>;\n};\n\nexport type ShareholdingTransaction = {\n  __typename?: 'ShareholdingTransaction';\n  amount?: Maybe<Scalars['CakeDecimal']['output']>;\n  attachedDocumentId?: Maybe<Scalars['UUID']['output']>;\n  attachedDocumentName?: Maybe<Scalars['String']['output']>;\n  beneficiary?: Maybe<Shareholder>;\n  certificate?: Maybe<Document>;\n  created: Scalars['DateTime']['output'];\n  /** Problem in this transaction that causes an inconsistent captable */\n  error?: Maybe<Scalars['String']['output']>;\n  /** Share transaction associated with this vesting transaction */\n  esoptransactionSet: Array<EsopTransaction>;\n  /** Share transaction associated with this vesting transaction */\n  esstransactionSet: Array<EssTransaction>;\n  /** Share transaction associated with this vesting transaction */\n  foundervestingtransactionSet: Array<FounderVestingTransactionOutputType>;\n  group: Scalars['UUID']['output'];\n  id: Scalars['UUID']['output'];\n  lastComment?: Maybe<Scalars['String']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** Transaction of note conversion shares issuance */\n  notetransactionSet: Array<NoteTransaction>;\n  paidInTransfer?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Share transaction associated with this vesting transaction */\n  rsutransactionSet: Array<RsuTransactionOutputType>;\n  shareSplitFactor?: Maybe<Scalars['CakeDecimal']['output']>;\n  shareholder?: Maybe<Shareholder>;\n  shares?: Maybe<Scalars['BigInt']['output']>;\n  sharetype: Sharetype;\n  transactionDate: Scalars['Date']['output'];\n  type: SeShareholdingTransactionTypeChoices;\n  unpaid?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Share transaction associated with this vesting transaction */\n  warranttransactionSet: Array<WarrantTransactionOutputType>;\n};\n\nexport type ShareholdingType = {\n  __typename?: 'ShareholdingType';\n  accumulatedShares?: Maybe<Scalars['BigInt']['output']>;\n  accumulatedSharetypeShares?: Maybe<Scalars['BigInt']['output']>;\n  amount?: Maybe<Scalars['CakeDecimal']['output']>;\n  attachedDocumentId?: Maybe<Scalars['UUID']['output']>;\n  attachedDocumentName?: Maybe<Scalars['String']['output']>;\n  lastComment?: Maybe<Scalars['String']['output']>;\n  lastShareCertificate?: Maybe<Document>;\n  paidInTransfer?: Maybe<Scalars['CakeDecimal']['output']>;\n  shareSplitFactor?: Maybe<Scalars['CakeDecimal']['output']>;\n  shareholderId?: Maybe<Scalars['UUID']['output']>;\n  shareholderName?: Maybe<Scalars['String']['output']>;\n  shares?: Maybe<Scalars['CakeDecimal']['output']>;\n  sharetype?: Maybe<Sharetype>;\n  transactionDate?: Maybe<Scalars['Date']['output']>;\n  transactionId?: Maybe<Scalars['UUID']['output']>;\n  transactionType?: Maybe<Scalars['String']['output']>;\n  unpaid?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\n/**\n *\n *     # The definition of a ShareType\n *     # Querying it the lists the attributes for a specified Sharetype.\n *\n *     query Example {sharetypes\n *         (organisationId: \"86318182-005b-427a-a3af-be07230a5e58\") {\n *                 id\n *                 name\n *             }\n *         }\n *\n */\nexport type Sharetype = {\n  __typename?: 'Sharetype';\n  /** Total authorized shares for this sharetype */\n  authorisedShares?: Maybe<Scalars['BigInt']['output']>;\n  cakegroupSet: Array<CakeGroupType>;\n  created: Scalars['DateTime']['output'];\n  /** Select Yes if share type has dividend payouts */\n  dividend: Scalars['Boolean']['output'];\n  esopofferSet: Array<EsopOffer>;\n  esopoffergroupSet: Array<EsopOfferGroup>;\n  essofferSet: Array<EssOffer>;\n  essoffergroupSet: Array<EssOfferGroup>;\n  foundervestingofferSet: Array<FounderVestingOfferOutputType>;\n  foundervestingoffergroupSet: Array<FounderVestingOfferGroupOutputType>;\n  id: Scalars['UUID']['output'];\n  investorholdingSet: Array<GroupedShareholdingType>;\n  investortrustholdingSet: Array<GroupedShareholdingInTrustType>;\n  modified: Scalars['DateTime']['output'];\n  /** Example : Ordinary , Preference, Test */\n  name: Scalars['String']['output'];\n  noteSet: Array<Note>;\n  notesroundSet: Array<NotesRoundType>;\n  notesroundofferSet: Array<NotesRoundOfferType>;\n  organisation: Organisation;\n  organisationraiseSet: Array<OrganisationRaise>;\n  rsuofferSet: Array<RsuOfferOutputType>;\n  rsuoffergroupSet: Array<RsuOfferGroupOutputType>;\n  sharecertificatedisclaimerSet: Array<ShareCertificateDisclaimerType>;\n  shareholdingtransactionSet: Array<ShareholdingTransaction>;\n  sharetransferofferSet: Array<ShareTransferOfferType>;\n  /** Share Symbol or Ticker , Example ALO */\n  symbol: Scalars['String']['output'];\n  totals?: Maybe<SharetypeTotals>;\n  /** Select Yes if share type has voting rights */\n  voting: Scalars['Boolean']['output'];\n  warrantofferSet: Array<WarrantOfferOutputType>;\n  warrantoffergroupSet: Array<WarrantOfferGroupOutputType>;\n  weight?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type SharetypeDisclaimerInputType = {\n  disclaimerId?: InputMaybe<Scalars['UUID']['input']>;\n  sharetypeId: Scalars['UUID']['input'];\n};\n\nexport type SharetypeHoldingType = {\n  __typename?: 'SharetypeHoldingType';\n  id?: Maybe<Scalars['UUID']['output']>;\n  investment?: Maybe<Scalars['CakeDecimal']['output']>;\n  name?: Maybe<Scalars['String']['output']>;\n  realShares?: Maybe<Scalars['BigInt']['output']>;\n  shares?: Maybe<Scalars['BigInt']['output']>;\n  symbol?: Maybe<Scalars['String']['output']>;\n  totalUnpaid?: Maybe<Scalars['CakeDecimal']['output']>;\n  unvestedShares?: Maybe<Scalars['BigInt']['output']>;\n  weight?: Maybe<Scalars['Float']['output']>;\n};\n\nexport type SharetypeReportEntry = {\n  __typename?: 'SharetypeReportEntry';\n  hasPlans?: Maybe<Scalars['Boolean']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  name?: Maybe<Scalars['String']['output']>;\n  symbol?: Maybe<Scalars['String']['output']>;\n};\n\nexport type SharetypeTotals = {\n  __typename?: 'SharetypeTotals';\n  amountRaised?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalDue?: Maybe<Scalars['CakeDecimal']['output']>;\n  totalShares?: Maybe<Scalars['BigInt']['output']>;\n};\n\n/**\n *\n *     # This mutation lets an investor sign a note agreement.\n *\n *         mutation Example {\n *             signNoteAgreement(\n *                 offerId: \"b280926e-8bae-4481-9d2c-d6a2d9694768\",\n *                 secondSignatureName: \"Bo Kranknap\",\n *                 secondSignatureEmail: \"bo.kr@hottimail.com\"\n *             )\n *             {\n *                 urlList, signatureRequestId\n *             }\n *         }\n *\n */\nexport type SignNoteAgreement = {\n  __typename?: 'SignNoteAgreement';\n  expectedCallbackUrl?: Maybe<Scalars['String']['output']>;\n  signatureRequestId?: Maybe<Scalars['String']['output']>;\n  urlList?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\n/**\n * # This mutation signs a document.\n *\n * mutation Example {\n *     signNoteAgreementOfficeholder (\n *         offerId: \"f3a522dd-a8f0-45a1-4444-0736162233c6\"\n *     )\n *     {\n *         urlList, signatureRequestId\n *     }\n * }\n */\nexport type SignNoteAgreementOfficeholder = {\n  __typename?: 'SignNoteAgreementOfficeholder';\n  expectedCallbackUrl?: Maybe<Scalars['String']['output']>;\n  signatureRequestId?: Maybe<Scalars['String']['output']>;\n  urlList?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\nexport type SignOfferLetterEsop = {\n  __typename?: 'SignOfferLetterEsop';\n  expectedCallbackUrl?: Maybe<Scalars['String']['output']>;\n  signatureRequestId?: Maybe<Scalars['String']['output']>;\n  urlList?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\nexport type SignOfferLetterEss = {\n  __typename?: 'SignOfferLetterEss';\n  expectedCallbackUrl?: Maybe<Scalars['String']['output']>;\n  signatureRequestId?: Maybe<Scalars['String']['output']>;\n  urlList?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\nexport type SignOfferLetterRsu = {\n  __typename?: 'SignOfferLetterRsu';\n  expectedCallbackUrl?: Maybe<Scalars['String']['output']>;\n  signatureRequestId?: Maybe<Scalars['String']['output']>;\n  urlList?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\n/**\n *\n *     # This mutation lets an investor sign a note agreement.\n *\n *         mutation Example {\n *             signNoteAgreement(\n *                 offerId: \"b280926e-8bae-4481-9d2c-d6a2d9694768\",\n *                 secondSignatureName: \"Bo Kranknap\",\n *                 secondSignatureEmail: \"bo.kr@hottimail.com\"\n *             )\n *             {\n *                 urlList, signatureRequestId\n *             }\n *         }\n *\n */\nexport type SignShareTransferAgreement = {\n  __typename?: 'SignShareTransferAgreement';\n  expectedCallbackUrl?: Maybe<Scalars['String']['output']>;\n  signatureRequestId?: Maybe<Scalars['String']['output']>;\n  urlList?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\n/**\n *\n *     # This mutation lets an investor sign a subscription agreement.\n *\n *         mutation Example {\n *             signSubscriptionAgreement(\n *                 offerId: \"b280926e-8bae-4481-9d2c-d6a2d9694768\",\n *                 witness: {\n *                     secondSignatureName: \"Bo Kranknap\",\n *                     secondSignatureEmail: \"bo.kr@hottimail.com\"\n *                 }\n *             )\n *             {\n *                 urlList, signatureRequestId\n *             }\n *         }\n *\n */\nexport type SignSubscriptionAgreement = {\n  __typename?: 'SignSubscriptionAgreement';\n  expectedCallbackUrl?: Maybe<Scalars['String']['output']>;\n  signatureRequestId?: Maybe<Scalars['String']['output']>;\n  urlList?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\n/**\n *\n *     # This mutation signs a document.\n *\n *     mutation Example {\n *         signSubscriptionAgreementOfficeholder (\n *             raiseOfferId: \"f3a522dd-a8f0-45a1-4444-0736162233c6\"\n *         )\n *         {\n *             urlList, signatureRequestId\n *         }\n *     }\n *\n */\nexport type SignSubscriptionAgreementOfficeholder = {\n  __typename?: 'SignSubscriptionAgreementOfficeholder';\n  expectedCallbackUrl?: Maybe<Scalars['String']['output']>;\n  signatureRequestId?: Maybe<Scalars['String']['output']>;\n  urlList?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\nexport type Signature = {\n  __typename?: 'Signature';\n  email?: Maybe<Scalars['String']['output']>;\n  extra?: Maybe<Scalars['String']['output']>;\n  name?: Maybe<Scalars['String']['output']>;\n  status?: Maybe<Scalars['String']['output']>;\n};\n\nexport type StakeholderAssetsPreviewType = {\n  __typename?: 'StakeholderAssetsPreviewType';\n  documentCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  messageCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  noteCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  sharetypeHoldings?: Maybe<Array<Maybe<SharetypeHoldingType>>>;\n  vestableHoldings?: Maybe<Array<Maybe<StakeholderVestablePlanHoldingsType>>>;\n};\n\nexport type StakeholderVestablePlanHoldingsType = {\n  __typename?: 'StakeholderVestablePlanHoldingsType';\n  granted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  planType?: Maybe<Scalars['String']['output']>;\n};\n\nexport type StartContractSigning = {\n  __typename?: 'StartContractSigning';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type StripeInvoicePaymentAttemptResult = {\n  __typename?: 'StripeInvoicePaymentAttemptResult';\n  payCount?: Maybe<Scalars['Int']['output']>;\n  pendingInvoiceIds?: Maybe<Array<Maybe<Scalars['String']['output']>>>;\n};\n\nexport type TimeSliceInputType = {\n  quantity: Scalars['PositiveInteger']['input'];\n  unit: Unit;\n};\n\nexport type TimeSliceType = {\n  __typename?: 'TimeSliceType';\n  quantity?: Maybe<Scalars['PositiveInteger']['output']>;\n  unit?: Maybe<Scalars['String']['output']>;\n};\n\nexport type ToggleMfaRequired = {\n  __typename?: 'ToggleMfaRequired';\n  mfaSetupNeeded?: Maybe<MfaSetupOutputType>;\n  required?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type TotalsQuarterEntry = {\n  __typename?: 'TotalsQuarterEntry';\n  newStakeholders?: Maybe<Array<Maybe<QuarterlyNewStakeholder>>>;\n  newStakeholdersCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  quarter?: Maybe<Scalars['Int']['output']>;\n  totalSecurities?: Maybe<Scalars['BigInt']['output']>;\n  totalStakeholders?: Maybe<Scalars['BigInt']['output']>;\n  year?: Maybe<Scalars['Int']['output']>;\n};\n\nexport type TransferSenderType = {\n  __typename?: 'TransferSenderType';\n  displayName?: Maybe<Scalars['String']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  secondaryId?: Maybe<Scalars['UUID']['output']>;\n  secondaryName?: Maybe<Scalars['String']['output']>;\n};\n\n/**\n *\n *     # This mutation transfers Shares from a shareholder to another.\n *     # Ensure sharetype between shareholders is same.\n *     # Ensure shareholder id's exist and user running query is an Officeholder.\n *\n *     mutation Example {\n *             transferShares (transferSharesData: {\n *                 fromShareholder: \"f3a5cddd-a8f0-45a1-b696-073616228bc8\"\n *                 toShareholder: \"7a8ee595-76e2-4a1a-bf64-7904c9180457\"\n *                 shareType: \"beb6dd77-53b1-4f5a-9e43-da52c1eb8973\"\n *                 quantity: 100\n *                 amount : 2350.50\n *                 transferDate: \"2019-01-25\"\n *             }) { organisation { id } }\n *     }\n *\n */\nexport type TransferShares = {\n  __typename?: 'TransferShares';\n  organisation?: Maybe<Organisation>;\n};\n\nexport type TransferSharesData = {\n  amount: Scalars['CakeDecimal']['input'];\n  fromBeneficiary?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  fromShareholder: Scalars['ShareholderCakeType']['input'];\n  quantity: Scalars['PositiveInteger']['input'];\n  shareType: Scalars['SharetypeCakeType']['input'];\n  toShareholder: Scalars['ShareholderCakeType']['input'];\n  toTrust?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  transferDate: Scalars['Date']['input'];\n};\n\n/** An enumeration. */\nexport enum TransfersShareTransferOfferStatusChoices {\n  /** Investor refused the offer */\n  Declined = 'DECLINED',\n  /** Waiting for Investor to confirm Details */\n  ReadyToConfirmDetails = 'READY_TO_CONFIRM_DETAILS',\n  /** Waiting for Investor to pay */\n  ReadyToPay = 'READY_TO_PAY',\n  /** Waiting for Investor Signatures */\n  ReadyToSign = 'READY_TO_SIGN',\n  /** Waiting for Officeholder to send Invitation */\n  ReadyToStart = 'READY_TO_START',\n  /** Waiting for Officeholder to Transfer the Shares */\n  ReadyToTransfer = 'READY_TO_TRANSFER',\n  /** Transfer concluded */\n  SharesTransferred = 'SHARES_TRANSFERRED'\n}\n\n/**\n *\n *     # The profile for a Shareholder.\n *     # Querying it lists Shareholders for a given organisationId.\n *\n *     query Example {shareholders\n *         (organisationId: \"604ad5d1-c44f-44b2-abb4-7877d96ed188\") {\n *                 id\n *                 name\n *             }\n *         }\n *\n */\nexport type TrustType = {\n  __typename?: 'TrustType';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  name: Scalars['String']['output'];\n  trustee: Shareholder;\n};\n\n/** An enumeration. */\nexport enum Unit {\n  Days = 'DAYS',\n  Hours = 'HOURS',\n  Minutes = 'MINUTES',\n  Months = 'MONTHS',\n  Seconds = 'SECONDS',\n  Years = 'YEARS'\n}\n\nexport type UpdateCakeGroup = {\n  __typename?: 'UpdateCakeGroup';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n *\n *     # This mutation updates the email subject and body in the document.\n *\n *         mutation Example {\n *             updateContractEmail(\n *                 documentId: \"8450926e-7777-9891-4345-d6a2d9694780\",\n *                 subject: \"Directors Resolution invitation to sign\",\n *                 body: \"Welcome to the team\"\n *             ) {\n *               ok\n *             }\n *         }\n *\n */\nexport type UpdateContractEmail = {\n  __typename?: 'UpdateContractEmail';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     updateEquityOfferPaymentStatus (\n *         offer: \"00000000-0000-0000-0000-000000000000\",\n *         paid: 350\n *     ) { ok }\n * }\n */\nexport type UpdateEquityOfferPaymentStatus = {\n  __typename?: 'UpdateEquityOfferPaymentStatus';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     updateEquityRoundBankDetailsAu (\n *         round: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type UpdateEquityRoundBankDetailsAu = {\n  __typename?: 'UpdateEquityRoundBankDetailsAu';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     updateEquityRoundBankDetailsFallback (\n *         round: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type UpdateEquityRoundBankDetailsFallback = {\n  __typename?: 'UpdateEquityRoundBankDetailsFallback';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     updateEquityRoundBankDetailsSg (\n *         round: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type UpdateEquityRoundBankDetailsSg = {\n  __typename?: 'UpdateEquityRoundBankDetailsSg';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     updateNotesOfferPaymentStatus (\n *         offer: \"00000000-0000-0000-0000-000000000000\",\n *         paid: 350\n *     ) { ok }\n * }\n */\nexport type UpdateNotesOfferPaymentStatus = {\n  __typename?: 'UpdateNotesOfferPaymentStatus';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     updateNotesRoundBankDetailsAu (\n *         round: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type UpdateNotesRoundBankDetailsAu = {\n  __typename?: 'UpdateNotesRoundBankDetailsAu';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     UpdateNotesRoundBankDetailsFallback (\n *         round: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type UpdateNotesRoundBankDetailsFallback = {\n  __typename?: 'UpdateNotesRoundBankDetailsFallback';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n * mutation {\n *     updateNotesRoundBankDetailsSg (\n *         round: \"00000000-0000-0000-0000-000000000000\"\n *     ) { ok }\n * }\n */\nexport type UpdateNotesRoundBankDetailsSg = {\n  __typename?: 'UpdateNotesRoundBankDetailsSg';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n *\n *     # This mutation Updates an existing officeholder. Ensure officeholder\n *     # id provided exists and user running the query is an Officeholder.\n *\n *     mutation Example {\n *         updateOfficeholder(\n *             updateOfficeholderData:{\n *                 officeholder:{\n *                     id:\"f3a5cddd-a8f0-45a1-b696-073616228bc6\",\n *                     name:\"Egon Jensen\",\n *                     email:\"hello@example.com\",\n *                     roles: [{\n *                         role: \"DIR\",\n *                     }]\n *                 }\n *             }\n *         ) {\n *             officeholder {\n *                 id\n *                 name\n *                 email\n *                 roles { role, name }\n *                 signer\n *                 signature\n *             }\n *         }\n *     }\n *\n */\nexport type UpdateOfficeholder = {\n  __typename?: 'UpdateOfficeholder';\n  officeholder?: Maybe<Officeholder>;\n};\n\nexport type UpdateOfficeholderData = {\n  officeholder?: InputMaybe<UpdateOfficeholderInput>;\n};\n\nexport type UpdateOfficeholderInput = {\n  email: Scalars['CleanString']['input'];\n  forceUpdateSigner?: InputMaybe<Scalars['Boolean']['input']>;\n  id: Scalars['UUID']['input'];\n  name: Scalars['CleanString']['input'];\n  permission?: InputMaybe<Scalars['String']['input']>;\n  roles: Array<InputMaybe<OfficeholderRoleInputType>>;\n  signer?: InputMaybe<Scalars['String']['input']>;\n};\n\nexport type UpdateOrganisationAu = {\n  __typename?: 'UpdateOrganisationAu';\n  organisation?: Maybe<Organisation>;\n};\n\nexport type UpdateOrganisationBasic = {\n  __typename?: 'UpdateOrganisationBasic';\n  organisation?: Maybe<Organisation>;\n};\n\nexport type UpdateOrganisationCa = {\n  __typename?: 'UpdateOrganisationCa';\n  organisation?: Maybe<Organisation>;\n};\n\nexport type UpdateOrganisationEe = {\n  __typename?: 'UpdateOrganisationEe';\n  organisation?: Maybe<Organisation>;\n};\n\nexport type UpdateOrganisationGb = {\n  __typename?: 'UpdateOrganisationGb';\n  organisation?: Maybe<Organisation>;\n};\n\nexport type UpdateOrganisationIn = {\n  __typename?: 'UpdateOrganisationIn';\n  organisation?: Maybe<Organisation>;\n};\n\nexport type UpdateOrganisationNz = {\n  __typename?: 'UpdateOrganisationNz';\n  organisation?: Maybe<Organisation>;\n};\n\nexport type UpdateOrganisationSg = {\n  __typename?: 'UpdateOrganisationSg';\n  organisation?: Maybe<Organisation>;\n};\n\nexport type UpdateOrganisationUs = {\n  __typename?: 'UpdateOrganisationUs';\n  organisation?: Maybe<Organisation>;\n};\n\nexport type UpdateShareTransferOfferPaymentStatus = {\n  __typename?: 'UpdateShareTransferOfferPaymentStatus';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\n/**\n *\n *     # This mutation Updates an existing sharetype. Ensure sharetype\n *     # id provided exists and user running the query is an Officeholder.\n *\n *     mutation Example {\n *         updateSharetype(\n *             updateSharetypeData:{\n *                 sharetype:{\n *                     id:\"f3a5cddd-a8f0-45a1-b696-073616228bc6\",\n *                     name:\"Ordinary\",\n *                     symbol:\"ORD\",\n *                     voting:false,\n *                     dividend:false,\n *                 }\n *             }\n *         ) {\n *             sharetype {\n *                 id\n *                 name\n *                 symbol\n *                 voting\n *                 dividend\n *                 totals {\n *                     amountRaised\n *                     totalShares\n *                     totalDue\n *                 }\n *                 }\n *             }\n *         }\n *\n */\nexport type UpdateSharetype = {\n  __typename?: 'UpdateSharetype';\n  sharetype?: Maybe<Sharetype>;\n};\n\nexport type UpdateSharetypeData = {\n  sharetype?: InputMaybe<UpdateSharetypeInput>;\n};\n\nexport type UpdateSharetypeInput = {\n  authorisedShares?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  dividend?: InputMaybe<Scalars['Boolean']['input']>;\n  id: Scalars['UUID']['input'];\n  name: Scalars['CleanString']['input'];\n  symbol: Scalars['CleanString']['input'];\n  voting?: InputMaybe<Scalars['Boolean']['input']>;\n  weight?: InputMaybe<Scalars['CakeDecimal']['input']>;\n};\n\nexport type UpdateSigner = {\n  __typename?: 'UpdateSigner';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type UpdateTransactionUnpaidAmount = {\n  __typename?: 'UpdateTransactionUnpaidAmount';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n};\n\nexport type UpgradeSubscription = {\n  __typename?: 'UpgradeSubscription';\n  ok?: Maybe<Scalars['Boolean']['output']>;\n  previousPlan?: Maybe<Scalars['String']['output']>;\n  targetPlan?: Maybe<Scalars['String']['output']>;\n};\n\nexport type UsCompanyDetailsField = {\n  __typename?: 'UsCompanyDetailsField';\n  created: Scalars['DateTime']['output'];\n  ein?: Maybe<Scalars['String']['output']>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  registeredAddress?: Maybe<InternationalAddressField>;\n  /** US State where company is incorporated */\n  stateOfRegistration: InternationalUsCompanyDetailsStateOfRegistrationChoices;\n};\n\nexport type UsCompanyDetailsInput = {\n  ein: Scalars['CleanString']['input'];\n  registeredAddress?: InputMaybe<AddressInput>;\n  stateOfRegistration?: InputMaybe<Scalars['CleanString']['input']>;\n};\n\n/** An enumeration. */\nexport enum UserAccountsUserSettingsCurrencyChoices {\n  /** UAE Dirham */\n  Aed = 'AED',\n  /** Afghani */\n  Afn = 'AFN',\n  /** Lek */\n  All = 'ALL',\n  /** Armenian Dram */\n  Amd = 'AMD',\n  /** Netherlands Antillean Guilder */\n  Ang = 'ANG',\n  /** Kwanza */\n  Aoa = 'AOA',\n  /** Argentine Peso */\n  Ars = 'ARS',\n  /** Australian Dollar */\n  Aud = 'AUD',\n  /** Aruban Florin */\n  Awg = 'AWG',\n  /** Azerbaijan Manat */\n  Azn = 'AZN',\n  /** Convertible Mark */\n  Bam = 'BAM',\n  /** Barbados Dollar */\n  Bbd = 'BBD',\n  /** Taka */\n  Bdt = 'BDT',\n  /** Bulgarian Lev */\n  Bgn = 'BGN',\n  /** Bahraini Dinar */\n  Bhd = 'BHD',\n  /** Burundi Franc */\n  Bif = 'BIF',\n  /** Bermudian Dollar */\n  Bmd = 'BMD',\n  /** Brunei Dollar */\n  Bnd = 'BND',\n  /** Boliviano */\n  Bob = 'BOB',\n  /** Mvdol */\n  Bov = 'BOV',\n  /** Brazilian Real */\n  Brl = 'BRL',\n  /** Bahamian Dollar */\n  Bsd = 'BSD',\n  /** Ngultrum */\n  Btn = 'BTN',\n  /** Pula */\n  Bwp = 'BWP',\n  /** Belarusian Ruble */\n  Byn = 'BYN',\n  /** Belize Dollar */\n  Bzd = 'BZD',\n  /** Canadian Dollar */\n  Cad = 'CAD',\n  /** Congolese Franc */\n  Cdf = 'CDF',\n  /** WIR Euro */\n  Che = 'CHE',\n  /** Swiss Franc */\n  Chf = 'CHF',\n  /** WIR Franc */\n  Chw = 'CHW',\n  /** Unidad de Fomento */\n  Clf = 'CLF',\n  /** Chilean Peso */\n  Clp = 'CLP',\n  /** Yuan Renminbi */\n  Cny = 'CNY',\n  /** Colombian Peso */\n  Cop = 'COP',\n  /** Unidad de Valor Real */\n  Cou = 'COU',\n  /** Costa Rican Colon */\n  Crc = 'CRC',\n  /** Peso Convertible */\n  Cuc = 'CUC',\n  /** Cuban Peso */\n  Cup = 'CUP',\n  /** Cabo Verde Escudo */\n  Cve = 'CVE',\n  /** Czech Koruna */\n  Czk = 'CZK',\n  /** Djibouti Franc */\n  Djf = 'DJF',\n  /** Danish Krone */\n  Dkk = 'DKK',\n  /** Dominican Peso */\n  Dop = 'DOP',\n  /** Algerian Dinar */\n  Dzd = 'DZD',\n  /** Egyptian Pound */\n  Egp = 'EGP',\n  /** Nakfa */\n  Ern = 'ERN',\n  /** Ethiopian Birr */\n  Etb = 'ETB',\n  /** Euro */\n  Eur = 'EUR',\n  /** Fiji Dollar */\n  Fjd = 'FJD',\n  /** Falkland Islands Pound */\n  Fkp = 'FKP',\n  /** Pound Sterling */\n  Gbp = 'GBP',\n  /** Lari */\n  Gel = 'GEL',\n  /** Ghana Cedi */\n  Ghs = 'GHS',\n  /** Gibraltar Pound */\n  Gip = 'GIP',\n  /** Dalasi */\n  Gmd = 'GMD',\n  /** Guinean Franc */\n  Gnf = 'GNF',\n  /** Quetzal */\n  Gtq = 'GTQ',\n  /** Guyana Dollar */\n  Gyd = 'GYD',\n  /** Hong Kong Dollar */\n  Hkd = 'HKD',\n  /** Lempira */\n  Hnl = 'HNL',\n  /** Kuna */\n  Hrk = 'HRK',\n  /** Gourde */\n  Htg = 'HTG',\n  /** Forint */\n  Huf = 'HUF',\n  /** Rupiah */\n  Idr = 'IDR',\n  /** New Israeli Sheqel */\n  Ils = 'ILS',\n  /** Indian Rupee */\n  Inr = 'INR',\n  /** Iraqi Dinar */\n  Iqd = 'IQD',\n  /** Iranian Rial */\n  Irr = 'IRR',\n  /** Iceland Krona */\n  Isk = 'ISK',\n  /** Jamaican Dollar */\n  Jmd = 'JMD',\n  /** Jordanian Dinar */\n  Jod = 'JOD',\n  /** Yen */\n  Jpy = 'JPY',\n  /** Kenyan Shilling */\n  Kes = 'KES',\n  /** Som */\n  Kgs = 'KGS',\n  /** Riel */\n  Khr = 'KHR',\n  /** Comorian Franc */\n  Kmf = 'KMF',\n  /** North Korean Won */\n  Kpw = 'KPW',\n  /** Won */\n  Krw = 'KRW',\n  /** Kuwaiti Dinar */\n  Kwd = 'KWD',\n  /** Cayman Islands Dollar */\n  Kyd = 'KYD',\n  /** Tenge */\n  Kzt = 'KZT',\n  /** Lao Kip */\n  Lak = 'LAK',\n  /** Lebanese Pound */\n  Lbp = 'LBP',\n  /** Sri Lanka Rupee */\n  Lkr = 'LKR',\n  /** Liberian Dollar */\n  Lrd = 'LRD',\n  /** Loti */\n  Lsl = 'LSL',\n  /** Libyan Dinar */\n  Lyd = 'LYD',\n  /** Moroccan Dirham */\n  Mad = 'MAD',\n  /** Moldovan Leu */\n  Mdl = 'MDL',\n  /** Malagasy Ariary */\n  Mga = 'MGA',\n  /** Denar */\n  Mkd = 'MKD',\n  /** Kyat */\n  Mmk = 'MMK',\n  /** Tugrik */\n  Mnt = 'MNT',\n  /** Pataca */\n  Mop = 'MOP',\n  /** Ouguiya */\n  Mru = 'MRU',\n  /** Mauritius Rupee */\n  Mur = 'MUR',\n  /** Rufiyaa */\n  Mvr = 'MVR',\n  /** Malawi Kwacha */\n  Mwk = 'MWK',\n  /** Mexican Peso */\n  Mxn = 'MXN',\n  /** Mexican Unidad de Inversion (UDI) */\n  Mxv = 'MXV',\n  /** Malaysian Ringgit */\n  Myr = 'MYR',\n  /** Mozambique Metical */\n  Mzn = 'MZN',\n  /** Namibia Dollar */\n  Nad = 'NAD',\n  /** Naira */\n  Ngn = 'NGN',\n  /** Cordoba Oro */\n  Nio = 'NIO',\n  /** Norwegian Krone */\n  Nok = 'NOK',\n  /** Nepalese Rupee */\n  Npr = 'NPR',\n  /** New Zealand Dollar */\n  Nzd = 'NZD',\n  /** Rial Omani */\n  Omr = 'OMR',\n  /** Balboa */\n  Pab = 'PAB',\n  /** Sol */\n  Pen = 'PEN',\n  /** Kina */\n  Pgk = 'PGK',\n  /** Philippine Peso */\n  Php = 'PHP',\n  /** Pakistan Rupee */\n  Pkr = 'PKR',\n  /** Zloty */\n  Pln = 'PLN',\n  /** Guarani */\n  Pyg = 'PYG',\n  /** Qatari Rial */\n  Qar = 'QAR',\n  /** Romanian Leu */\n  Ron = 'RON',\n  /** Serbian Dinar */\n  Rsd = 'RSD',\n  /** Russian Ruble */\n  Rub = 'RUB',\n  /** Rwanda Franc */\n  Rwf = 'RWF',\n  /** Saudi Riyal */\n  Sar = 'SAR',\n  /** Solomon Islands Dollar */\n  Sbd = 'SBD',\n  /** Seychelles Rupee */\n  Scr = 'SCR',\n  /** Sudanese Pound */\n  Sdg = 'SDG',\n  /** Swedish Krona */\n  Sek = 'SEK',\n  /** Singapore Dollar */\n  Sgd = 'SGD',\n  /** Saint Helena Pound */\n  Shp = 'SHP',\n  /** Leone 2022 */\n  Sle = 'SLE',\n  /** Leone */\n  Sll = 'SLL',\n  /** Somali Shilling */\n  Sos = 'SOS',\n  /** Surinam Dollar */\n  Srd = 'SRD',\n  /** South Sudanese Pound */\n  Ssp = 'SSP',\n  /** Dobra */\n  Stn = 'STN',\n  /** El Salvador Colon */\n  Svc = 'SVC',\n  /** Syrian Pound */\n  Syp = 'SYP',\n  /** Lilangeni */\n  Szl = 'SZL',\n  /** Baht */\n  Thb = 'THB',\n  /** Somoni */\n  Tjs = 'TJS',\n  /** Turkmenistan New Manat */\n  Tmt = 'TMT',\n  /** Tunisian Dinar */\n  Tnd = 'TND',\n  /** Pa'anga */\n  Top = 'TOP',\n  /** Turkish Lira */\n  Try = 'TRY',\n  /** Trinidad and Tobago Dollar */\n  Ttd = 'TTD',\n  /** New Taiwan Dollar */\n  Twd = 'TWD',\n  /** Tanzanian Shilling */\n  Tzs = 'TZS',\n  /** Hryvnia */\n  Uah = 'UAH',\n  /** Uganda Shilling */\n  Ugx = 'UGX',\n  /** US Dollar */\n  Usd = 'USD',\n  /** Uruguay Peso en Unidades Indexadas (UI) */\n  Uyi = 'UYI',\n  /** Peso Uruguayo */\n  Uyu = 'UYU',\n  /** Unidad Previsional */\n  Uyw = 'UYW',\n  /** Uzbekistan Sum */\n  Uzs = 'UZS',\n  /** Bolívar Soberano */\n  Ves = 'VES',\n  /** Dong */\n  Vnd = 'VND',\n  /** Vatu */\n  Vuv = 'VUV',\n  /** Tala */\n  Wst = 'WST',\n  /** CFA Franc BEAC */\n  Xaf = 'XAF',\n  /** East Caribbean Dollar */\n  Xcd = 'XCD',\n  /** CFA Franc BCEAO */\n  Xof = 'XOF',\n  /** CFP Franc */\n  Xpf = 'XPF',\n  /** Yemeni Rial */\n  Yer = 'YER',\n  /** Rand */\n  Zar = 'ZAR',\n  /** Zambian Kwacha */\n  Zmw = 'ZMW',\n  /** Zimbabwe Dollar */\n  Zwl = 'ZWL'\n}\n\nexport type UserAssociatedOrganisationsType = {\n  __typename?: 'UserAssociatedOrganisationsType';\n  organisationId?: Maybe<Scalars['UUID']['output']>;\n  organisationName?: Maybe<Scalars['CleanString']['output']>;\n  role?: Maybe<Scalars['CleanString']['output']>;\n};\n\nexport type UserCompanyPreferencesType = {\n  __typename?: 'UserCompanyPreferencesType';\n  /** has gone to 409A page from checklist */\n  checklistRequest409a: Scalars['Boolean']['output'];\n  created: Scalars['DateTime']['output'];\n  /** if has completed the free checklist */\n  hasCompletedFreeChecklist: Scalars['Boolean']['output'];\n  /** if has completed the growth checklist */\n  hasCompletedGrowthChecklist: Scalars['Boolean']['output'];\n  /** if has completed the pro checklist */\n  hasCompletedProChecklist: Scalars['Boolean']['output'];\n  /** if has completed the starter checklist */\n  hasCompletedStarterChecklist: Scalars['Boolean']['output'];\n  /** if has used benchmarking */\n  hasUsedBenchmarking: Scalars['Boolean']['output'];\n  /** if has used exit estimator */\n  hasUsedExitEstimator: Scalars['Boolean']['output'];\n  /** if has used modelling */\n  hasUsedModelling: Scalars['Boolean']['output'];\n  /** if has used reporting */\n  hasUsedReporting: Scalars['Boolean']['output'];\n  /** If the team portal preview has been opened */\n  hasViewedTeamPortal: Scalars['Boolean']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** if add country upgrade inside option pool wasn't dismissed */\n  showAddCountryUpgrade: Scalars['Boolean']['output'];\n  /** if the annual plan upgrade banner wasn't dismissed */\n  showAnnualPlanUpgradeBanner: Scalars['Boolean']['output'];\n  /** if the expired 409A banner wasn't dismissed */\n  showExpired409aBanner: Scalars['Boolean']['output'];\n  /** if the growth free banner wasn't dismissed */\n  showGrowthFreeBanner: Scalars['Boolean']['output'];\n  /** if the import cap table banner wasn't dismissed */\n  showImportCaptableBanner: Scalars['Boolean']['output'];\n  /** if the paid power-up banner wasn't dismissed */\n  showPaidPowerUpBanner: Scalars['Boolean']['output'];\n  /** if the QSBS upgrade banner wasn't dismissed */\n  showQsbsUpgradeBanner: Scalars['Boolean']['output'];\n  /** if the shareholder survey banner wasn't dismissed */\n  showShareholderSurveyBanner: Scalars['Boolean']['output'];\n  /** if the what's new banner wasn't dismissed */\n  showWhatsNewBanner: Scalars['Boolean']['output'];\n};\n\nexport type UserEmployeeGoalOutputType = {\n  __typename?: 'UserEmployeeGoalOutputType';\n  emotion?: Maybe<Scalars['String']['output']>;\n  goal?: Maybe<Scalars['String']['output']>;\n  meaning?: Maybe<Scalars['String']['output']>;\n};\n\nexport type UserOrganisationStatusType = {\n  __typename?: 'UserOrganisationStatusType';\n  hasValidLicense?: Maybe<Scalars['Boolean']['output']>;\n  organisationId?: Maybe<Scalars['UUID']['output']>;\n  organisationName?: Maybe<Scalars['String']['output']>;\n};\n\nexport type UserOrganisationsType = {\n  __typename?: 'UserOrganisationsType';\n  exchangeRates?: Maybe<Array<Maybe<ExchangeRateType>>>;\n  hasVisibleValuation?: Maybe<Scalars['Boolean']['output']>;\n  organisationData?: Maybe<Array<Maybe<OrgData>>>;\n};\n\nexport type UserSettingsOutputType = {\n  __typename?: 'UserSettingsOutputType';\n  /** User prefered currency code according to ISO 4217 */\n  currency: UserAccountsUserSettingsCurrencyChoices;\n};\n\nexport type UserType = {\n  __typename?: 'UserType';\n  email: Scalars['String']['output'];\n  firstName: Scalars['String']['output'];\n  hasEnrolledMfa?: Maybe<Scalars['Boolean']['output']>;\n  hasLoggedIn?: Maybe<Scalars['Boolean']['output']>;\n  id: Scalars['UUID']['output'];\n  isLoggedInUser?: Maybe<Scalars['Boolean']['output']>;\n  lastName: Scalars['String']['output'];\n  mfaWhitelist?: Maybe<Scalars['Boolean']['output']>;\n  name?: Maybe<Scalars['String']['output']>;\n  picture: Scalars['String']['output'];\n  termsAndConditions?: Maybe<Scalars['JSONString']['output']>;\n};\n\nexport type UserWithAggregatedRoles = {\n  __typename?: 'UserWithAggregatedRoles';\n  position?: Maybe<Scalars['String']['output']>;\n  role?: Maybe<Scalars['String']['output']>;\n  roleWeight?: Maybe<Scalars['Int']['output']>;\n  user?: Maybe<UserType>;\n};\n\nexport type ValuationType = {\n  __typename?: 'ValuationType';\n  created: Scalars['DateTime']['output'];\n  /** Date of valuation */\n  date: Scalars['Date']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  organisation: Organisation;\n  organisationraiseSet: Array<OrganisationRaise>;\n  round?: Maybe<OrganisationsValuationRoundChoices>;\n  valuation?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type VestableHoldingType = {\n  __typename?: 'VestableHoldingType';\n  availableToExercise?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToLapse?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  exercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  granted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  offerSoftStatus?: Maybe<Scalars['String']['output']>;\n  offerStatus?: Maybe<Scalars['String']['output']>;\n  planId?: Maybe<Scalars['UUID']['output']>;\n  planName?: Maybe<Scalars['String']['output']>;\n  vested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type VestableholderReportEntry = {\n  __typename?: 'VestableholderReportEntry';\n  displayName?: Maybe<Scalars['CleanString']['output']>;\n  exercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  granted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  id?: Maybe<Scalars['UUID']['output']>;\n  lapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestingValue?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type VestingCalendarOutputEntry = {\n  __typename?: 'VestingCalendarOutputEntry';\n  accelerated?: Maybe<Scalars['Boolean']['output']>;\n  accumulated?: Maybe<Scalars['BigInt']['output']>;\n  date?: Maybe<Scalars['Date']['output']>;\n  entryType?: Maybe<Scalars['String']['output']>;\n  lapsed?: Maybe<Scalars['BigInt']['output']>;\n  tampered?: Maybe<Scalars['Boolean']['output']>;\n  transactionId?: Maybe<Scalars['UUID']['output']>;\n  vestingValue?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type VestingCliffOutputType = {\n  __typename?: 'VestingCliffOutputType';\n  vestStartDate?: Maybe<Scalars['Date']['output']>;\n  vestingData?: Maybe<VestingDataOutputType>;\n};\n\nexport type VestingDataInputType = {\n  description?: InputMaybe<Scalars['CleanString']['input']>;\n  duration?: InputMaybe<VestingTimeSliceInputType>;\n  frequency?: InputMaybe<VestingTimeSliceInputType>;\n  reminderDate?: InputMaybe<Scalars['Date']['input']>;\n};\n\nexport type VestingDataOutputType = {\n  __typename?: 'VestingDataOutputType';\n  description?: Maybe<Scalars['String']['output']>;\n  duration?: Maybe<VestingTimeSliceOutputType>;\n  frequency?: Maybe<VestingTimeSliceOutputType>;\n  reminderDate?: Maybe<Scalars['Date']['output']>;\n};\n\nexport type VestingEventInputType = {\n  vestingData: VestingDataInputType;\n  vestingValue: Scalars['PositiveInteger']['input'];\n};\n\n/** An enumeration. */\nexport enum VestingGranularity {\n  Days = 'DAYS',\n  Months = 'MONTHS',\n  Years = 'YEARS'\n}\n\nexport enum VestingGranularityOutputField {\n  Days = 'DAYS',\n  Months = 'MONTHS',\n  Years = 'YEARS'\n}\n\nexport type VestingPlanTransaction = {\n  __typename?: 'VestingPlanTransaction';\n  attachedDocumentId?: Maybe<Scalars['UUID']['output']>;\n  attachedDocumentName?: Maybe<Scalars['String']['output']>;\n  exercisePrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  lastComment?: Maybe<Scalars['String']['output']>;\n  planName?: Maybe<Scalars['String']['output']>;\n  shareholder?: Maybe<Shareholder>;\n  sharetype?: Maybe<Sharetype>;\n  transactionDate?: Maybe<Scalars['Date']['output']>;\n  transactionId?: Maybe<Scalars['UUID']['output']>;\n  transactionType?: Maybe<Scalars['String']['output']>;\n  vestingValue?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\n/** An enumeration. */\nexport enum VestingPlanType {\n  Esop = 'ESOP',\n  Ess = 'ESS',\n  Foundervesting = 'FOUNDERVESTING',\n  Phantom = 'PHANTOM',\n  Rsu = 'RSU',\n  Warrant = 'WARRANT'\n}\n\nexport type VestingScheduleTemplateEventInputType = {\n  vestingData: VestingDataInputType;\n  vestingValuePercentage: Scalars['CakeDecimal']['input'];\n};\n\nexport type VestingScheduleTemplateEventOutputType = {\n  __typename?: 'VestingScheduleTemplateEventOutputType';\n  eventType?: Maybe<Scalars['String']['output']>;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  vestingData?: Maybe<VestingDataOutputType>;\n  vestingValuePercentage?: Maybe<Scalars['CakeDecimal']['output']>;\n};\n\nexport type VestingScheduleTemplateInputType = {\n  events: Array<InputMaybe<VestingScheduleTemplateEventInputType>>;\n};\n\nexport type VestingScheduleTemplateType = {\n  __typename?: 'VestingScheduleTemplateType';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  name?: Maybe<Scalars['String']['output']>;\n  /** Organisation */\n  organisation: Organisation;\n  vestingEvents?: Maybe<Array<Maybe<VestingScheduleTemplateEventOutputType>>>;\n};\n\nexport type VestingTimeSliceInputType = {\n  granularity: VestingGranularity;\n  value: Scalars['PositiveIntegerOrZero']['input'];\n};\n\nexport type VestingTimeSliceOutputType = {\n  __typename?: 'VestingTimeSliceOutputType';\n  granularity?: Maybe<VestingGranularityOutputField>;\n  value?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n};\n\nexport type WarrantOfferBulkEntryInputType = {\n  administrativeArea1?: InputMaybe<Scalars['String']['input']>;\n  administrativeArea2?: InputMaybe<Scalars['String']['input']>;\n  allowTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  autoGrant?: InputMaybe<Scalars['Boolean']['input']>;\n  conversionLockEvent?: InputMaybe<Scalars['CleanString']['input']>;\n  country?: InputMaybe<Scalars['String']['input']>;\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  exerciseExpireDate?: InputMaybe<Scalars['Date']['input']>;\n  exerciseExpireTime?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  exercisePrice: Scalars['CakeDecimal']['input'];\n  grantDate?: InputMaybe<Scalars['Date']['input']>;\n  line1?: InputMaybe<Scalars['String']['input']>;\n  line2?: InputMaybe<Scalars['String']['input']>;\n  line3?: InputMaybe<Scalars['String']['input']>;\n  locality?: InputMaybe<Scalars['String']['input']>;\n  name: Scalars['CleanString']['input'];\n  postcode?: InputMaybe<Scalars['String']['input']>;\n  sharetypeId: Scalars['UUID']['input'];\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n  vestingEvents: Array<InputMaybe<VestingEventInputType>>;\n};\n\nexport type WarrantOfferGroupOutputType = {\n  __typename?: 'WarrantOfferGroupOutputType';\n  /** Allow offer holders to nominate a trust */\n  allowNomineeTrust: Scalars['Boolean']['output'];\n  autoGenerated: Scalars['Boolean']['output'];\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  defaultExerciseExpireTime?: Maybe<TimeSliceType>;\n  /** Default Offer Letter template used by this plan */\n  defaultOfferLetterTemplate?: Maybe<Document>;\n  /** Default Plan Rules template used by this plan */\n  defaultPlanRulesTemplate?: Maybe<Document>;\n  /** Disclosure period in days */\n  disclosurePeriodDays: Scalars['Int']['output'];\n  id: Scalars['UUID']['output'];\n  isEditable?: Maybe<Scalars['Boolean']['output']>;\n  /** Whether the shares were paid for via a company load */\n  loanFunded: Scalars['Boolean']['output'];\n  modified: Scalars['DateTime']['output'];\n  offerAcceptedCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  offerCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Offer Letter template used by this WARRANT */\n  offerLetterTemplate: Array<Document>;\n  /** WARRANT this group belongs to */\n  plan: WarrantOutputType;\n  /** Plan Rules template used by this WARRANT */\n  planRulesTemplate: Array<Document>;\n  /** Require board approval before sending offers */\n  requireBoardApproval: Scalars['Boolean']['output'];\n  sharePrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  sharetype?: Maybe<Sharetype>;\n  totalExercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalGranted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalLapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalOffered?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalVested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Offer common fields */\n  warrantofferSet: Array<WarrantOfferOutputType>;\n};\n\nexport type WarrantOfferInputType = {\n  allowEarlyExercise?: InputMaybe<Scalars['Boolean']['input']>;\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  autoLapseOnExpirationDate?: InputMaybe<Scalars['Boolean']['input']>;\n  conversionLockEvent?: InputMaybe<Scalars['CleanString']['input']>;\n  currency?: InputMaybe<Scalars['String']['input']>;\n  emailsOn?: InputMaybe<Scalars['Boolean']['input']>;\n  exerciseExpirationStartingPoint?: InputMaybe<Scalars['CleanString']['input']>;\n  exerciseExpireDate?: InputMaybe<Scalars['Date']['input']>;\n  exerciseExpireTime?: InputMaybe<TimeSliceInputType>;\n  exercisePrice: Scalars['CakeDecimal']['input'];\n  grantDate?: InputMaybe<Scalars['Date']['input']>;\n  postTerminationExercisePeriod?: InputMaybe<TimeSliceInputType>;\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n  sendExpirationNotification?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype: Scalars['SharetypeCakeType']['input'];\n  vestStartDate?: InputMaybe<Scalars['Date']['input']>;\n  vestingEvents: Array<InputMaybe<VestingEventInputType>>;\n};\n\nexport type WarrantOfferOutputType = {\n  __typename?: 'WarrantOfferOutputType';\n  /** Allow exercising into share vesting. */\n  allowEarlyExercise: Scalars['Boolean']['output'];\n  /** Allow option holders to nominate a trust */\n  allowNomineeTrust: Scalars['Boolean']['output'];\n  /** Whether or not the options lapse automatically on the expiration date. */\n  autoLapseOnExpirationDate?: Maybe<Scalars['Boolean']['output']>;\n  availableToExercise?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToLapse?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToPeriodicVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVest?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  availableToVestMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Investor/employee share holding entity */\n  bareTrustTrustee?: Maybe<Shareholder>;\n  boardApproval?: Maybe<BoardApprovalType>;\n  calendar?: Maybe<OfferCalendarOutputType>;\n  conversionLockDate?: Maybe<Scalars['Date']['output']>;\n  country?: Maybe<Scalars['String']['output']>;\n  created: Scalars['DateTime']['output'];\n  currency?: Maybe<Scalars['String']['output']>;\n  dateGranted?: Maybe<Scalars['Date']['output']>;\n  /** Disclosure period in days */\n  disclosurePeriodDays: Scalars['Int']['output'];\n  /** True means sending regular vesting emails to investor */\n  emailsOn: Scalars['Boolean']['output'];\n  /** The date from when the time starts counting towards the expiration. */\n  exerciseExpirationStartingPoint?: Maybe<WarrantWarrantOfferExerciseExpirationStartingPointChoices>;\n  /** Date when options expire if not exercised */\n  exerciseExpireDate?: Maybe<Scalars['Date']['output']>;\n  /** Time based period from vested/granted where options expire if not exercised */\n  exerciseExpireTime?: Maybe<TimeSliceType>;\n  /** Exercise price */\n  exercisePrice: Scalars['Decimal']['output'];\n  exercised?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Holds the date when the email notification is sent. Should be null otherwise. */\n  expirationNotificationDate?: Maybe<Scalars['Date']['output']>;\n  /** The day the offer is granted (override) */\n  grantDateDefault?: Maybe<Scalars['Date']['output']>;\n  granted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  /** Offer common fields */\n  group: WarrantOfferGroupOutputType;\n  hasOngoingPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasScheduledPauseEvents?: Maybe<Scalars['Boolean']['output']>;\n  hasTransactions?: Maybe<Scalars['Boolean']['output']>;\n  id: Scalars['UUID']['output'];\n  /** The date the offer moved to READY_TO_CONFIRM_DETAILS */\n  inviteDate?: Maybe<Scalars['Date']['output']>;\n  lapsed?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsedMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lapsedPeriodic?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  lastEventDate?: Maybe<Scalars['Date']['output']>;\n  lastRepricingDate?: Maybe<Scalars['Date']['output']>;\n  /** Whether the shares were paid for via a company load */\n  loanFunded: Scalars['Boolean']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** The next vesting date computed daily by the calendar calculator */\n  nextVestingDate?: Maybe<Scalars['Date']['output']>;\n  /** The next vesting meta computed daily by the calendar calculator */\n  nextVestingMeta?: Maybe<WarrantWarrantOfferNextVestingMetaChoices>;\n  /** Offboarding settings for this offer */\n  offboardSettings?: Maybe<OffboardEventSettingsOutputType>;\n  /** Signer Offer Letter for this WARRANT offer */\n  offerLetter?: Maybe<Document>;\n  offerLetterOpt?: Maybe<Document>;\n  /** Template to generate the offer letter from */\n  offerLetterTemplate?: Maybe<Document>;\n  pauseEvents?: Maybe<Array<Maybe<WarrantOfferPauseEventOutputType>>>;\n  plan?: Maybe<WarrantOutputType>;\n  /** Plan Rules for this WARRANT */\n  planRules?: Maybe<Document>;\n  /** Template to generate the Plan Rules from, or final doc */\n  planRulesTemplate?: Maybe<Document>;\n  /** PTEP settings for this offer */\n  ptepSettings?: Maybe<PtepSettingsOutputType>;\n  /** Makes it a requirement that a witness also needs to sign the offer letter. */\n  requireWitness: Scalars['Boolean']['output'];\n  /** Determines if an email will be sent some days before the expiration. */\n  sendExpirationNotification?: Maybe<Scalars['Boolean']['output']>;\n  /** Investor/employee holder entity */\n  shareholder: Shareholder;\n  shareholderDisplayName?: Maybe<Scalars['String']['output']>;\n  shareholderOpt?: Maybe<Shareholder>;\n  sharetype?: Maybe<Sharetype>;\n  softStatus?: Maybe<Scalars['String']['output']>;\n  status?: Maybe<Scalars['String']['output']>;\n  totalCliffDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalGranted?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  totalPeriodicDays?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestStartDate?: Maybe<Scalars['Date']['output']>;\n  vestableMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestablePeriodic?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vested?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestedMilestone?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  vestedPeriodic?: Maybe<Scalars['CakeDecimal']['output']>;\n  vestingEvents?: Maybe<Array<Maybe<WarrantVestingEventOutputType>>>;\n  warrantofferpauseeventSet: Array<WarrantOfferPauseEventOutputType>;\n  /** WARRANT offer */\n  warranttransactionSet: Array<WarrantTransactionOutputType>;\n  /** WARRANT offer */\n  warrantvestingeventSet: Array<WarrantVestingEventOutputType>;\n};\n\nexport type WarrantOfferPauseEventOutputType = {\n  __typename?: 'WarrantOfferPauseEventOutputType';\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  offer: WarrantOfferOutputType;\n  /** Date when vest pause starts */\n  pauseDate: Scalars['Date']['output'];\n  /** Date when vest pause ends */\n  resumeDate: Scalars['Date']['output'];\n  status?: Maybe<Scalars['String']['output']>;\n};\n\nexport type WarrantOutputType = {\n  __typename?: 'WarrantOutputType';\n  autoGenerated: Scalars['Boolean']['output'];\n  cakegroupSet: Array<CakeGroupType>;\n  commentCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  created: Scalars['DateTime']['output'];\n  documents?: Maybe<Array<Maybe<Document>>>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** Name of this vesting plan */\n  name?: Maybe<Scalars['String']['output']>;\n  offerGroup?: Maybe<Array<Maybe<WarrantOfferGroupOutputType>>>;\n  /** Organisation this plan belongs to */\n  organisation: Organisation;\n  percentageOfOrganisationShares?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Makes it a requirement that a witness also needs to sign the offer letter. */\n  requireWitness: Scalars['Boolean']['output'];\n  totalExercised?: Maybe<Scalars['BigInt']['output']>;\n  totalGranted?: Maybe<Scalars['BigInt']['output']>;\n  totalLapsed?: Maybe<Scalars['BigInt']['output']>;\n  totalOffered?: Maybe<Scalars['BigInt']['output']>;\n  totalVested?: Maybe<Scalars['BigInt']['output']>;\n  vestingValue?: Maybe<Scalars['BigInt']['output']>;\n  /** WARRANT this group belongs to */\n  warrantoffergroupSet: Array<WarrantOfferGroupOutputType>;\n};\n\nexport type WarrantTransactionOutputType = {\n  __typename?: 'WarrantTransactionOutputType';\n  /** True if this transaction is accelerated */\n  accelerated: Scalars['Boolean']['output'];\n  /** Document relevant for this transaction (eg: Option repricing board approval) */\n  attachment?: Maybe<Document>;\n  commentCount?: Maybe<Scalars['PositiveIntegerOrZero']['output']>;\n  created: Scalars['DateTime']['output'];\n  id: Scalars['UUID']['output'];\n  /** True is manually inserted, False if it comes from the auto-vest algo */\n  isManual: Scalars['Boolean']['output'];\n  lastComment?: Maybe<Scalars['String']['output']>;\n  modified: Scalars['DateTime']['output'];\n  /** WARRANT offer */\n  offer: WarrantOfferOutputType;\n  sharePrice?: Maybe<Scalars['CakeDecimal']['output']>;\n  /** Share transaction associated with this vesting transaction */\n  shareTransaction?: Maybe<ShareholdingTransaction>;\n  sharetype?: Maybe<Sharetype>;\n  /** Transaction date */\n  transactionDate: Scalars['Date']['output'];\n  /** Transaction type (eg. vested, exercised, lapsed */\n  type: WarrantWarrantTransactionTypeChoices;\n  /** Offer Vesting Event */\n  vestingEvent?: Maybe<WarrantVestingEventOutputType>;\n  vestingValue?: Maybe<Scalars['BigInt']['output']>;\n};\n\nexport type WarrantVestingEventOutputType = {\n  __typename?: 'WarrantVestingEventOutputType';\n  created: Scalars['DateTime']['output'];\n  eventType?: Maybe<Scalars['String']['output']>;\n  id: Scalars['UUID']['output'];\n  modified: Scalars['DateTime']['output'];\n  /** WARRANT offer */\n  offer: WarrantOfferOutputType;\n  offerId?: Maybe<Scalars['UUID']['output']>;\n  /** Event order */\n  order: Scalars['Int']['output'];\n  vestingData?: Maybe<VestingDataOutputType>;\n  /** Amount offered to investor/employee in this event */\n  vestingValue: Scalars['BigInt']['output'];\n  /** Offer Vesting Event */\n  warranttransactionSet: Array<WarrantTransactionOutputType>;\n};\n\n/** An enumeration. */\nexport enum WarrantWarrantOfferExerciseExpirationStartingPointChoices {\n  /** Grant date */\n  GrantDate = 'GRANT_DATE',\n  /** Vest start date */\n  VestStartDate = 'VEST_START_DATE'\n}\n\n/** An enumeration. */\nexport enum WarrantWarrantOfferNextVestingMetaChoices {\n  /** Fully vesting */\n  FullyVesting = 'FULLY_VESTING',\n  /** Meeting milestone */\n  MeetingMilestone = 'MEETING_MILESTONE',\n  /** Periodic vesting */\n  PeriodicVesting = 'PERIODIC_VESTING',\n  /** Reaching cliff */\n  ReachingCliff = 'REACHING_CLIFF',\n  /** Unknown */\n  Unknown = 'UNKNOWN'\n}\n\n/** An enumeration. */\nexport enum WarrantWarrantTransactionTypeChoices {\n  /** EXERCISED */\n  Exercised = 'EXERCISED',\n  /** GRANTED */\n  Granted = 'GRANTED',\n  /** LAPSED */\n  Lapsed = 'LAPSED',\n  /** REPRICED */\n  Repriced = 'REPRICED',\n  /** VESTED */\n  Vested = 'VESTED'\n}\n\nexport type WitnessInputType = {\n  email: Scalars['CleanString']['input'];\n  name: Scalars['CleanString']['input'];\n};\n\nexport type OrganisationDetailsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type OrganisationDetailsQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', id: string, name: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, fundingPhase?: string | null, created: string, logoImage?: string | null, companyDetails?:\n      | { __typename?: 'AuCompanyDetailsField', acn?: string | null, registrationLocation?: string | null, registeredAgentName?: string | null, registeredAgentEmail?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'CaCompanyDetailsField', bn?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'EeCompanyDetailsField', brc?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'GbCompanyDetailsField', crn?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'InCompanyDetailsField', cin?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'NzCompanyDetailsField', nzbn?: string | null, registeredAgentName?: string | null, registeredAgentEmail?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'SgCompanyDetailsField', uen?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'UsCompanyDetailsField', stateOfRegistration: InternationalUsCompanyDetailsStateOfRegistrationChoices, ein?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n     | null, officeholderSet: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, roles: Array<{ __typename?: 'OfficeholderRoleType', role: SeOfficeholderRoleRoleChoices, name?: string | null }> }> } | null };\n\nexport type UserOrganisationStatusQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type UserOrganisationStatusQuery = { __typename?: 'Query', userOrgStatus?: Array<{ __typename?: 'UserOrganisationStatusType', organisationId?: string | null, organisationName?: string | null, hasValidLicense?: boolean | null } | null> | null };\n\nexport type SendEmployeeLicenseBlockEmailMutationVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type SendEmployeeLicenseBlockEmailMutation = { __typename?: 'Mutation', sendEmployeeLicenseBlockEmail?: boolean | null };\n\nexport type DocumentsHomeQueryVariables = Exact<{\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type DocumentsHomeQuery = { __typename?: 'Query', shareholderDocs?: { __typename?: 'PaginatedDocuments', currentPage: number, count: number, pageData?: Array<{ __typename?: 'Document', id: string, name?: string | null, modified: string, extension?: string | null, organisation: { __typename?: 'Organisation', logoImageLink?: string | null, name: string, id: string } } | null> | null } | null };\n\nexport type HomeEntrypointQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type HomeEntrypointQuery = { __typename?: 'Query', homeEntrypoint?: { __typename?: 'HomeEntrypointType', hasSecurities?: boolean | null, hasPendingOffers?: boolean | null, ongoingCliff?: string | null, hasUnreadMessages?: boolean | null, hasDocuments?: boolean | null, ongoingVestingList?: Array<\n      | { __typename: 'EsopOffer', id: string }\n      | { __typename: 'EssOffer', id: string }\n      | { __typename: 'RsuOfferOutputType', id: string }\n      | { __typename: 'WarrantOfferOutputType', id: string }\n     | null> | null } | null };\n\nexport type UserOrganisationsQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type UserOrganisationsQuery = { __typename?: 'Query', userOrganisations?: { __typename?: 'UserOrganisationsType', hasVisibleValuation?: boolean | null, exchangeRates?: Array<{ __typename?: 'ExchangeRateType', fromCurrency?: string | null, toCurrency?: string | null, rate?: number | null } | null> | null, organisationData?: Array<{ __typename?: 'OrgData', id?: string | null, name?: string | null, logo?: string | null, currency?: string | null, valuation?: number | null, fullyDiluted?: number | null } | null> | null } | null };\n\nexport type HomeDocumentsQueryVariables = Exact<{\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type HomeDocumentsQuery = { __typename?: 'Query', shareholderDocs?: { __typename?: 'PaginatedDocuments', pageData?: Array<{ __typename?: 'Document', id: string, name?: string | null, modified: string, extension?: string | null, organisation: { __typename?: 'Organisation', logo: string, name: string, id: string } } | null> | null } | null };\n\nexport type HomeMessagesQueryVariables = Exact<{\n  page?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n}>;\n\n\nexport type HomeMessagesQuery = { __typename?: 'Query', investorMessages?: { __typename?: 'PaginatedMessageType', pageData?: Array<{ __typename?: 'CakeMessageType', id: string, subject: string, bodyParsed?: string | null, created: string, attachments: Array<{ __typename?: 'Document', id: string }>, user?: { __typename?: 'UserType', firstName: string, lastName: string, picture: string } | null, organisation: { __typename?: 'Organisation', id: string, name: string } } | null> | null } | null };\n\nexport type HomePortfolioQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type HomePortfolioQuery = { __typename?: 'Query', portfolioHome?: Array<{ __typename?: 'PortfolioHomeOutputType', shareholder?: { __typename?: 'Shareholder', id: string, organisation: { __typename?: 'Organisation', id: string, name: string, logo: string } } | null, groupedShareholdings?: Array<{ __typename: 'GroupedShareholdingType', totalShares?: number | null } | null> | null, groupedShareholdingsInTrust?: Array<{ __typename: 'GroupedShareholdingInTrustType', totalShares?: number | null } | null> | null, groupedNoteholdings?: Array<{ __typename: 'GroupedNoteholdingType', totalNotes?: number | null, totalInvested?: number | null } | null> | null, groupedPlanData?: Array<{ __typename: 'PortfolioPlanHoldingOutputType', planType?: VestingPlanType | null, totalGranted?: number | null, totalVested?: number | null, totalExercised?: number | null, totalLapsed?: number | null, vestingNext?: { __typename?: 'VestingCalendarOutputEntry', vestingValue?: number | null } | null } | null> | null } | null> | null };\n\nexport type HomeOffersPendingQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type HomeOffersPendingQuery = { __typename?: 'Query', userOffers?: Array<\n    | { __typename: 'EsopOffer', id: string, modified: string, group: { __typename?: 'EsopOfferGroup', plan: { __typename?: 'Esop', organisation: { __typename?: 'Organisation', id: string, name: string, logo?: string | null } } } }\n    | { __typename: 'EssOffer', id: string, modified: string, group: { __typename?: 'EssOfferGroup', plan: { __typename?: 'Ess', organisation: { __typename?: 'Organisation', id: string, name: string, logo?: string | null } } } }\n    | { __typename: 'NotesRoundOfferType', id: string, modified: string, notesRound: { __typename?: 'NotesRoundType', organisation: { __typename?: 'Organisation', id: string, name: string, logo?: string | null } } }\n    | { __typename: 'OrganisationRaiseOffer', id: string, modified: string, organisationRaise: { __typename?: 'OrganisationRaise', organisation: { __typename?: 'Organisation', id: string, name: string, logo?: string | null } } }\n    | { __typename: 'RsuOfferOutputType', id: string, modified: string, group: { __typename?: 'RsuOfferGroupOutputType', plan: { __typename?: 'RsuOutputType', organisation: { __typename?: 'Organisation', id: string, name: string, logo?: string | null } } } }\n    | { __typename: 'ShareTransferOfferType', id: string, modified: string, sharetype: { __typename?: 'Sharetype', organisation: { __typename?: 'Organisation', id: string, name: string, logo?: string | null } } }\n   | null> | null };\n\nexport type UserEmployeeGoalQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type UserEmployeeGoalQuery = { __typename?: 'Query', userEmployeeGoal?: { __typename?: 'UserEmployeeGoalOutputType', emotion?: string | null, goal?: string | null, meaning?: string | null } | null };\n\nexport type VestingCliffQueryVariables = Exact<{\n  eventId: Scalars['UUID']['input'];\n}>;\n\n\nexport type VestingCliffQuery = { __typename?: 'Query', vestingCliff?: { __typename?: 'VestingCliffOutputType', vestStartDate?: string | null, vestingData?: { __typename?: 'VestingDataOutputType', duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null };\n\nexport type HomeOffersEarningChartQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type HomeOffersEarningChartQuery = { __typename?: 'Query', esopOfferList?: Array<{ __typename: 'EsopOffer', id: string, granted?: number | null, vested?: number | null, group: { __typename?: 'EsopOfferGroup', id: string, country?: string | null, plan: { __typename?: 'Esop', name?: string | null, organisation: { __typename?: 'Organisation', id: string } } }, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null } | null> | null, essOfferList?: Array<{ __typename: 'EssOffer', id: string, granted?: number | null, vested?: number | null, group: { __typename?: 'EssOfferGroup', id: string, country?: string | null, plan: { __typename?: 'Ess', name?: string | null, organisation: { __typename?: 'Organisation', id: string } } }, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null } | null> | null, rsuOfferList?: Array<{ __typename: 'RsuOfferOutputType', id: string, granted?: number | null, vested?: number | null, group: { __typename?: 'RsuOfferGroupOutputType', id: string, country?: string | null, plan: { __typename?: 'RsuOutputType', name?: string | null, organisation: { __typename?: 'Organisation', id: string } } }, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null } | null> | null, warrantOfferList?: Array<{ __typename: 'WarrantOfferOutputType', id: string, granted?: number | null, vested?: number | null, group: { __typename?: 'WarrantOfferGroupOutputType', id: string, country?: string | null, plan: { __typename?: 'WarrantOutputType', name?: string | null, organisation: { __typename?: 'Organisation', id: string } } }, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null } | null> | null };\n\nexport type SetUserEmployeeGoalMutationVariables = Exact<{\n  emotion: Scalars['CleanString']['input'];\n  goal: Scalars['CleanString']['input'];\n  meaning: Scalars['CleanString']['input'];\n}>;\n\n\nexport type SetUserEmployeeGoalMutation = { __typename?: 'Mutation', setUserEmployeeGoal?: boolean | null };\n\nexport type InvestorInboxQueryVariables = Exact<{\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n}>;\n\n\nexport type InvestorInboxQuery = { __typename?: 'Query', investorInbox: { __typename?: 'PaginatedInboxListType', count: number, currentPage: number, pageData: Array<{ __typename?: 'InboxItemType', id: string, organisationId: string, organisationName: string, avatarImage?: string | null, avatarName?: string | null, threadLength: number, created: string, subject: string, nRecipients: number, hasAttachments: boolean, hasUnreadMessages: boolean, lastMessageStatus: MessageStatus }> } };\n\nexport type InvestorMessageThreadQueryVariables = Exact<{\n  replyThreadId: Scalars['CakeReplyThreadCakeType']['input'];\n  page?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  inReply?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type InvestorMessageThreadQuery = { __typename?: 'Query', investorMessageThread?: { __typename?: 'CakeReplyThreadType', id: string, participants?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null }>, replyingShareholders?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null } | null> | null, rootMessage: { __typename?: 'CakeMessageType', allowReactions: boolean, allowReplies?: boolean | null, ownReaction?: string | null, id: string, created: string, subject: string, body: string, bodyParsed?: string | null, isSeen?: boolean | null, isDraft?: boolean | null, replyThread?: { __typename?: 'CakeReplyThreadType', id: string } | null, reactionAggregates?: Array<{ __typename?: 'CakeMessageReactionCountType', reaction?: string | null, count?: number | null, stakeholders?: Array<string | null> | null } | null> | null, attachments: Array<{ __typename?: 'Document', id: string, name?: string | null, modified: string, extension?: string | null }>, user?: { __typename?: 'UserType', firstName: string, lastName: string, picture: string } | null, organisation: { __typename?: 'Organisation', id: string, name: string, logo?: string | null } }, messages?: { __typename?: 'PaginatedMessageType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'CakeMessageType', created: string, id: string, subject: string, body: string, isDraft?: boolean | null, isSeen?: boolean | null, isCompanyMessage?: boolean | null, organisation: { __typename?: 'Organisation', id: string, name: string, logo?: string | null }, user?: { __typename?: 'UserType', firstName: string, lastName: string, picture: string } | null, attachments: Array<{ __typename?: 'Document', id: string, name?: string | null, modified: string, extension?: string | null }> } | null> | null } | null } | null };\n\nexport type MessageReactionUpdateMutationVariables = Exact<{\n  message: Scalars['CakeMessageCakeType']['input'];\n  reaction: Scalars['CleanString']['input'];\n}>;\n\n\nexport type MessageReactionUpdateMutation = { __typename?: 'Mutation', updateMessageReaction?: boolean | null };\n\nexport type OffersHomeQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type OffersHomeQuery = { __typename?: 'Query', userOffers?: Array<\n    | { __typename: 'EsopOffer', id: string, modified: string, softStatus?: string | null, exercisePrice?: number | null, optionPrice?: number | null, currency?: string | null, shareholder: { __typename?: 'Shareholder', displayName?: string | null }, group: { __typename?: 'EsopOfferGroup', currency?: string | null, plan: { __typename?: 'Esop', name?: string | null, organisation: { __typename?: 'Organisation', id: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, name: string, logo?: string | null } } }, vestingEvents?: Array<{ __typename?: 'EsopVestingEventType', vestingValue: number } | null> | null }\n    | { __typename: 'EssOffer', id: string, modified: string, softStatus?: string | null, shareholder: { __typename?: 'Shareholder', displayName?: string | null, organisation: { __typename?: 'Organisation', type?: string | null } }, group: { __typename?: 'EssOfferGroup', plan: { __typename?: 'Ess', name?: string | null, organisation: { __typename?: 'Organisation', id: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, name: string, logo?: string | null } } }, vestingEvents?: Array<{ __typename?: 'EssVestingEventType', vestingValue: number } | null> | null }\n    | { __typename: 'NotesRoundOfferType', id: string, principal?: number | null, paid?: number | null, notesStatus: NotesroundsNotesRoundOfferStatusChoices, contract?: { __typename?: 'Document', id: string } | null, notesRound: { __typename?: 'NotesRoundType', name: string, roundInvestmentGoal?: number | null, noteType: NotesroundsNotesRoundNoteTypeChoices, organisation: { __typename?: 'Organisation', id: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, name: string, logo?: string | null } } }\n    | { __typename: 'OrganisationRaiseOffer', id: string, amount?: number | null, paid?: number | null, equityStatus: SeOrganisationRaiseOfferStatusChoices, contract?: { __typename?: 'Document', id: string } | null, organisationRaise: { __typename?: 'OrganisationRaise', name?: string | null, raiseGoalAmount?: number | null, organisation: { __typename?: 'Organisation', id: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, name: string, logo?: string | null } } }\n    | { __typename: 'RsuOfferOutputType', id: string, modified: string, softStatus?: string | null, shareholder: { __typename?: 'Shareholder', displayName?: string | null }, group: { __typename?: 'RsuOfferGroupOutputType', plan: { __typename?: 'RsuOutputType', name?: string | null, organisation: { __typename?: 'Organisation', id: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, name: string, logo?: string | null } } }, vestingEvents?: Array<{ __typename?: 'RsuVestingEventOutputType', vestingValue: number } | null> | null }\n    | { __typename: 'ShareTransferOfferType', id: string, isSeller?: boolean | null, shares: number, amount?: number | null, status: TransfersShareTransferOfferStatusChoices, shareTransferAgreementContract?: { __typename?: 'Document', id: string } | null, fromShareholder: { __typename?: 'Shareholder', displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null }, toShareholder: { __typename?: 'Shareholder', displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null }, sharetype: { __typename?: 'Sharetype', symbol: string, organisation: { __typename?: 'Organisation', id: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, name: string, logo?: string | null } } }\n   | null> | null };\n\nexport type SendKudosMutationVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n  actionType: Scalars['CleanString']['input'];\n  selectedBadge: Scalars['CleanString']['input'];\n  userMessage: Scalars['String']['input'];\n}>;\n\n\nexport type SendKudosMutation = { __typename?: 'Mutation', sendKudos?: boolean | null };\n\nexport type ForceUpdateSigningStatusMutationVariables = Exact<{\n  document: Scalars['DocumentCakeType']['input'];\n}>;\n\n\nexport type ForceUpdateSigningStatusMutation = { __typename?: 'Mutation', forceUpdateSigningStatus?: boolean | null };\n\nexport type OffersDetailsEsopQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type OffersDetailsEsopQuery = { __typename?: 'Query', esopOffer?: { __typename?: 'EsopOffer', id: string, created: string, modified: string, inviteDate?: string | null, disclosurePeriodDays: number, allowNomineeTrust: boolean, country?: string | null, requireWitness: boolean, hasTransactions?: boolean | null, vestStartDate?: string | null, dateGranted?: string | null, status?: string | null, softStatus?: string | null, optionPrice?: number | null, exercisePrice?: number | null, currency?: string | null, optionType?: EsopEsopOfferOptionTypeChoices | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null } | null }, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null, offerLetter?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null, signatures?: Array<{ __typename?: 'Signature', email?: string | null, status?: string | null } | null> | null } | null, planRules?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null } | null, offerLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null } | null, planRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null } | null, vestingEvents?: Array<{ __typename?: 'EsopVestingEventType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'EsopTransaction', id: string }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null, group: { __typename?: 'EsopOfferGroup', id: string, country?: string | null, currency?: string | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null, plan: { __typename?: 'Esop', name?: string | null, organisation: { __typename?: 'Organisation', id: string, type?: string | null, name: string, currency: OrganisationsOrganisationCurrencyChoices, fullyDilutedShares?: number | null, totalShares?: number | null, totalSharesUnexercised?: number | null, valuationVisibleToOptionholders?: boolean | null, ownershipVisibleToOptionholders?: boolean | null, logo?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null }, documents?: Array<{ __typename?: 'Document', id: string, name?: string | null, file?: string | null } | null> | null } } } | null };\n\nexport type ConfirmOfferInvestorDetailsEsopMutationVariables = Exact<{\n  offerId: Scalars['EsopOfferCakeType']['input'];\n  recipientData: ShareholderDataInput;\n  trustData?: InputMaybe<ShareholderDataInput>;\n}>;\n\n\nexport type ConfirmOfferInvestorDetailsEsopMutation = { __typename?: 'Mutation', confirmOfferInvestorDetailsEsop?: boolean | null };\n\nexport type DeclineOfferEsopMutationVariables = Exact<{\n  esopOfferId: Scalars['EsopOfferCakeType']['input'];\n}>;\n\n\nexport type DeclineOfferEsopMutation = { __typename?: 'Mutation', declineOfferEsop?: boolean | null };\n\nexport type SignOfferLetterEsopMutationVariables = Exact<{\n  offerId: Scalars['EsopOfferCakeType']['input'];\n  witness?: InputMaybe<WitnessInputType>;\n}>;\n\n\nexport type SignOfferLetterEsopMutation = { __typename?: 'Mutation', signOfferLetterEsop?: { __typename?: 'SignOfferLetterEsop', urlList?: Array<string | null> | null, signatureRequestId?: string | null, expectedCallbackUrl?: string | null } | null };\n\nexport type OffersDetailsEssQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type OffersDetailsEssQuery = { __typename?: 'Query', essOffer?: { __typename?: 'EssOffer', id: string, created: string, modified: string, inviteDate?: string | null, disclosurePeriodDays: number, allowNomineeTrust: boolean, country?: string | null, requireWitness: boolean, hasTransactions?: boolean | null, vestStartDate?: string | null, sharePrice?: number | null, loanFunded: boolean, dateGranted?: string | null, status?: string | null, softStatus?: string | null, group: { __typename?: 'EssOfferGroup', id: string, country?: string | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null, plan: { __typename?: 'Ess', name?: string | null, organisation: { __typename?: 'Organisation', id: string, type?: string | null, name: string, currency: OrganisationsOrganisationCurrencyChoices, fullyDilutedShares?: number | null, totalShares?: number | null, totalSharesUnexercised?: number | null, valuationVisibleToShareholders?: boolean | null, ownershipVisibleToShareholders?: boolean | null, logo?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null }, documents?: Array<{ __typename?: 'Document', id: string, name?: string | null, file?: string | null } | null> | null } }, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, organisation: { __typename?: 'Organisation', type?: string | null }, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null } | null }, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null, offerLetter?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null, signatures?: Array<{ __typename?: 'Signature', email?: string | null, status?: string | null } | null> | null } | null, planRules?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null } | null, offerLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null } | null, planRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null } | null, vestingEvents?: Array<{ __typename?: 'EssVestingEventType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'EssTransaction', id: string }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null } | null };\n\nexport type ConfirmOfferInvestorDetailsEssMutationVariables = Exact<{\n  offerId: Scalars['EssOfferCakeType']['input'];\n  recipientData: ShareholderDataInput;\n  trustData?: InputMaybe<ShareholderDataInput>;\n}>;\n\n\nexport type ConfirmOfferInvestorDetailsEssMutation = { __typename?: 'Mutation', confirmOfferInvestorDetailsEss?: boolean | null };\n\nexport type DeclineOfferEssMutationVariables = Exact<{\n  essOfferId: Scalars['EssOfferCakeType']['input'];\n}>;\n\n\nexport type DeclineOfferEssMutation = { __typename?: 'Mutation', declineOfferEss?: boolean | null };\n\nexport type SignOfferLetterEssMutationVariables = Exact<{\n  offerId: Scalars['EssOfferCakeType']['input'];\n  witness?: InputMaybe<WitnessInputType>;\n}>;\n\n\nexport type SignOfferLetterEssMutation = { __typename?: 'Mutation', signOfferLetterEss?: { __typename?: 'SignOfferLetterEss', urlList?: Array<string | null> | null, signatureRequestId?: string | null, expectedCallbackUrl?: string | null } | null };\n\nexport type OffersDetailsRaiseEquityQueryVariables = Exact<{\n  offerId: Scalars['OrganisationRaiseOfferCakeType']['input'];\n}>;\n\n\nexport type OffersDetailsRaiseEquityQuery = { __typename?: 'Query', investorEquityOffer?: { __typename?: 'OrganisationRaiseOffer', id: string, amount?: number | null, status: SeOrganisationRaiseOfferStatusChoices, requireWitness: boolean, organisationRaise: { __typename?: 'OrganisationRaise', name?: string | null, valuation?: number | null, existingShares?: number | null, raiseGoalAmount?: number | null, endDate?: string | null, shareType: { __typename?: 'Sharetype', name: string }, documents?: Array<{ __typename?: 'Document', id: string, name?: string | null, extension?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null> | null, organisation: { __typename?: 'Organisation', id: string, name: string, logo: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, valuationVisibleToShareholders?: boolean | null, ownershipVisibleToShareholders?: boolean | null }, contractTemplate?: { __typename?: 'Document', id: string, name?: string | null, extension?: string | null, contractType?: string | null, contractProvider?: string | null, status?: string | null } | null, payment?:\n        | { __typename: 'AuPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, bsb?: string | null, reference?: string | null, isTrustAccount?: boolean | null }\n        | { __typename: 'FallbackPaymentDetailsType', details?: string | null }\n        | { __typename: 'SgPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, swiftCode?: string | null, bankCode?: string | null, branchCode?: string | null }\n       | null }, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null } | null }, contract?: { __typename?: 'Document', id: string, name?: string | null, created: string, extension?: string | null, contractType?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null, extra?: string | null } | null> | null } | null } | null };\n\nexport type ConfirmEquityOfferInvestorDetailsMutationVariables = Exact<{\n  offerId: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  shareholderData: ShareholderDataInput;\n}>;\n\n\nexport type ConfirmEquityOfferInvestorDetailsMutation = { __typename?: 'Mutation', confirmEquityOfferInvestorDetails?: { __typename?: 'ConfirmEquityOfferInvestorDetails', ok?: boolean | null } | null };\n\nexport type DeclineEquityOfferMutationVariables = Exact<{\n  equityOfferId: Scalars['OrganisationRaiseOfferCakeType']['input'];\n}>;\n\n\nexport type DeclineEquityOfferMutation = { __typename?: 'Mutation', declineEquityOffer?: { __typename?: 'DeclineEquityOffer', ok?: boolean | null } | null };\n\nexport type AcceptEquityOfferMutationVariables = Exact<{\n  equityOfferId: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  amount: Scalars['CakeDecimal']['input'];\n}>;\n\n\nexport type AcceptEquityOfferMutation = { __typename?: 'Mutation', acceptEquityOffer?: { __typename?: 'AcceptEquityOffer', ok?: boolean | null } | null };\n\nexport type SignSubscriptionAgreementMutationVariables = Exact<{\n  offerId: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  witness?: InputMaybe<WitnessInputType>;\n}>;\n\n\nexport type SignSubscriptionAgreementMutation = { __typename?: 'Mutation', signSubscriptionAgreement?: { __typename?: 'SignSubscriptionAgreement', urlList?: Array<string | null> | null, signatureRequestId?: string | null, expectedCallbackUrl?: string | null } | null };\n\nexport type OffersDetailsRaiseNotesQueryVariables = Exact<{\n  offerId: Scalars['NotesRoundOfferCakeType']['input'];\n}>;\n\n\nexport type OffersDetailsRaiseNotesQuery = { __typename?: 'Query', investorNoteOffer?: { __typename?: 'NotesRoundOfferType', id: string, principal?: number | null, status: NotesroundsNotesRoundOfferStatusChoices, valuationCap?: number | null, discountRate?: number | null, interestRate?: number | null, maturityDate?: string | null, noteType?: NoteType | null, requireWitness: boolean, payment?:\n      | { __typename?: 'AuPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, bsb?: string | null, reference?: string | null, isTrustAccount?: boolean | null }\n      | { __typename?: 'FallbackPaymentDetailsType', details?: string | null }\n      | { __typename?: 'SgPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, swiftCode?: string | null, bankCode?: string | null, branchCode?: string | null }\n     | null, notesRound: { __typename?: 'NotesRoundType', name: string, documents?: Array<{ __typename?: 'Document', id: string, name?: string | null, extension?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null> | null, organisation: { __typename?: 'Organisation', id: string, name: string, logo: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices } }, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null } | null }, contract?: { __typename?: 'Document', id: string, created: string, name?: string | null, extension?: string | null, contractType?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null } | null> | null } | null } | null };\n\nexport type ConfirmNotesOfferInvestorDetailsMutationVariables = Exact<{\n  offerId: Scalars['NotesRoundOfferCakeType']['input'];\n  shareholderData: ShareholderDataInput;\n}>;\n\n\nexport type ConfirmNotesOfferInvestorDetailsMutation = { __typename?: 'Mutation', confirmNotesOfferInvestorDetails?: { __typename?: 'ConfirmNotesOfferInvestorDetails', ok?: boolean | null } | null };\n\nexport type DeclineNotesOfferMutationVariables = Exact<{\n  notesOfferId: Scalars['NotesRoundOfferCakeType']['input'];\n}>;\n\n\nexport type DeclineNotesOfferMutation = { __typename?: 'Mutation', declineNotesOffer?: { __typename?: 'DeclineNotesOffer', ok?: boolean | null } | null };\n\nexport type AcceptNotesOfferMutationVariables = Exact<{\n  notesOfferId: Scalars['NotesRoundOfferCakeType']['input'];\n  principal?: InputMaybe<Scalars['CakeDecimal']['input']>;\n}>;\n\n\nexport type AcceptNotesOfferMutation = { __typename?: 'Mutation', acceptNotesOffer?: { __typename?: 'AcceptNotesOffer', ok?: boolean | null } | null };\n\nexport type SignNoteAgreementMutationVariables = Exact<{\n  offerId: Scalars['NotesRoundOfferCakeType']['input'];\n  witness?: InputMaybe<WitnessInputType>;\n}>;\n\n\nexport type SignNoteAgreementMutation = { __typename?: 'Mutation', signNoteAgreement?: { __typename?: 'SignNoteAgreement', urlList?: Array<string | null> | null, signatureRequestId?: string | null, expectedCallbackUrl?: string | null } | null };\n\nexport type OffersDetailsRsuQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type OffersDetailsRsuQuery = { __typename?: 'Query', rsuOffer?: { __typename?: 'RsuOfferOutputType', id: string, created: string, modified: string, inviteDate?: string | null, disclosurePeriodDays: number, allowNomineeTrust: boolean, country?: string | null, requireWitness: boolean, hasTransactions?: boolean | null, vestStartDate?: string | null, dateGranted?: string | null, status?: string | null, softStatus?: string | null, group: { __typename?: 'RsuOfferGroupOutputType', id: string, country?: string | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null, plan: { __typename?: 'RsuOutputType', name?: string | null, organisation: { __typename?: 'Organisation', id: string, type?: string | null, name: string, currency: OrganisationsOrganisationCurrencyChoices, fullyDilutedShares?: number | null, totalShares?: number | null, totalSharesUnexercised?: number | null, valuationVisibleToShareholders?: boolean | null, ownershipVisibleToShareholders?: boolean | null, logo?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null }, documents?: Array<{ __typename?: 'Document', id: string, name?: string | null, file?: string | null } | null> | null } }, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null } | null }, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null, offerLetter?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null, signatures?: Array<{ __typename?: 'Signature', email?: string | null, status?: string | null } | null> | null } | null, planRules?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null } | null, offerLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null } | null, planRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, status?: string | null } | null, vestingEvents?: Array<{ __typename?: 'RsuVestingEventOutputType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'RsuTransactionOutputType', id: string }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null, conversionlockevent?: { __typename?: 'RsuConversionLockEventOutputType', description: string } | null } | null };\n\nexport type ConfirmOfferInvestorDetailsRsuMutationVariables = Exact<{\n  offerId: Scalars['RsuOfferCakeType']['input'];\n  recipientData: ShareholderDataInput;\n  trustData?: InputMaybe<ShareholderDataInput>;\n}>;\n\n\nexport type ConfirmOfferInvestorDetailsRsuMutation = { __typename?: 'Mutation', confirmOfferInvestorDetailsRsu?: boolean | null };\n\nexport type DeclineOfferRsuMutationVariables = Exact<{\n  rsuOfferId: Scalars['RsuOfferCakeType']['input'];\n}>;\n\n\nexport type DeclineOfferRsuMutation = { __typename?: 'Mutation', declineOfferRsu?: boolean | null };\n\nexport type SignOfferLetterRsuMutationVariables = Exact<{\n  offerId: Scalars['RsuOfferCakeType']['input'];\n  witness?: InputMaybe<WitnessInputType>;\n}>;\n\n\nexport type SignOfferLetterRsuMutation = { __typename?: 'Mutation', signOfferLetterRsu?: { __typename?: 'SignOfferLetterRsu', urlList?: Array<string | null> | null, signatureRequestId?: string | null, expectedCallbackUrl?: string | null } | null };\n\nexport type OffersDetailsTransfersQueryVariables = Exact<{\n  offerId: Scalars['ShareTransferOfferCakeType']['input'];\n}>;\n\n\nexport type OffersDetailsTransfersQuery = { __typename?: 'Query', shareTransferOffer?: { __typename?: 'ShareTransferOfferType', isSeller?: boolean | null, id: string, shares: number, amount?: number | null, status: TransfersShareTransferOfferStatusChoices, fromShareholderConfirmed?: boolean | null, toShareholderConfirmed?: boolean | null, fromShareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null } | null }, toShareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null } | null }, sharetype: { __typename?: 'Sharetype', id: string, name: string, symbol: string }, shareTransferAgreementContract?: { __typename?: 'Document', id: string, created: string, name?: string | null, contractType?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null, extra?: string | null } | null> | null } | null, offlineContract?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null } | null, shareTransferRound: { __typename?: 'ShareTransferRoundType', id: string, name: string, organisation: { __typename?: 'Organisation', id: string, name: string, logo: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, type?: string | null }, documents?: Array<{ __typename?: 'Document', id: string, name?: string | null, extension?: string | null, created: string, type: DocumentsDocumentTypeChoices, status?: string | null } | null> | null } } | null };\n\nexport type ConfirmShareTransferOfferInvestorDetailsMutationVariables = Exact<{\n  offerId: Scalars['ShareTransferOfferCakeType']['input'];\n  shareholderData: ShareholderDataInput;\n}>;\n\n\nexport type ConfirmShareTransferOfferInvestorDetailsMutation = { __typename?: 'Mutation', confirmShareTransferOfferInvestorDetails?: { __typename?: 'ConfirmShareTransferOfferInvestorDetails', transferOffer?: { __typename?: 'ShareTransferOfferType', fromShareholderConfirmed?: boolean | null, toShareholderConfirmed?: boolean | null } | null } | null };\n\nexport type DeclineShareTransferOfferMutationVariables = Exact<{\n  transferOfferId: Scalars['ShareTransferOfferCakeType']['input'];\n}>;\n\n\nexport type DeclineShareTransferOfferMutation = { __typename?: 'Mutation', declineShareTransferOffer?: { __typename?: 'DeclineShareTransferOffer', ok?: boolean | null } | null };\n\nexport type SignShareTransferAgreementMutationVariables = Exact<{\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n}>;\n\n\nexport type SignShareTransferAgreementMutation = { __typename?: 'Mutation', signShareTransferAgreement?: { __typename?: 'SignShareTransferAgreement', urlList?: Array<string | null> | null, signatureRequestId?: string | null, expectedCallbackUrl?: string | null } | null };\n\nexport type PortfolioOfferDetailsEsopQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type PortfolioOfferDetailsEsopQuery = { __typename?: 'Query', esopOfferDetails?: { __typename?: 'EsopOffer', id: string, optionPrice?: number | null, exercisePrice?: number | null, currency?: string | null, granted?: number | null, vested?: number | null, exercised?: number | null, lapsed?: number | null, availableToExercise?: number | null, shareholder: { __typename?: 'Shareholder', displayName?: string | null, avatar?: string | null }, group: { __typename?: 'EsopOfferGroup', country?: string | null, exercisePrice?: number | null, optionPrice?: number | null, currency?: string | null, plan: { __typename?: 'Esop', name?: string | null, organisation: { __typename?: 'Organisation', id: string, name: string, currency: OrganisationsOrganisationCurrencyChoices, valuationVisibleToOptionholders?: boolean | null, ownershipVisibleToOptionholders?: boolean | null, fullyDilutedShares?: number | null, totalShares?: number | null, totalSharesUnexercised?: number | null, logo?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null } } }, transactionSet: Array<{ __typename?: 'EsopTransaction', type: EsopEsopTransactionTypeChoices, transactionDate: string, vestingValue?: number | null }>, esopvestingeventSet: Array<{ __typename?: 'EsopVestingEventType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'EsopTransaction', id: string, transactionDate: string, vestingValue?: number | null, type: EsopEsopTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, reminderDate?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null }>, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null, offerLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, planRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, offerLetter?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, planRules?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null } | null };\n\nexport type PortfolioOffersListEsopQueryVariables = Exact<{\n  employee: Scalars['ShareholderCakeType']['input'];\n}>;\n\n\nexport type PortfolioOffersListEsopQuery = { __typename?: 'Query', esopOfferList?: Array<{ __typename?: 'EsopOffer', id: string, group: { __typename?: 'EsopOfferGroup', id: string, country?: string | null, plan: { __typename?: 'Esop', name?: string | null } } } | null> | null };\n\nexport type RequestExerciseMutationVariables = Exact<{\n  offerId: Scalars['EsopOfferCakeType']['input'];\n  options: Scalars['PositiveInteger']['input'];\n  taxWithholding?: InputMaybe<Scalars['CakeDecimal']['input']>;\n}>;\n\n\nexport type RequestExerciseMutation = { __typename?: 'Mutation', requestExercise?: boolean | null };\n\nexport type CanRequestExerciseQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type CanRequestExerciseQuery = { __typename?: 'Query', canRequestExercise?: boolean | null };\n\nexport type PrepareRequestExerciseQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type PrepareRequestExerciseQuery = { __typename?: 'Query', esopOfferDetails?: { __typename?: 'EsopOffer', exercisePrice?: number | null, currency?: string | null, availableToExercise?: number | null, requestedToExercise?: number | null, granted?: number | null, lapsed?: number | null, exercised?: number | null, group: { __typename?: 'EsopOfferGroup', country?: string | null, plan: { __typename?: 'Esop', organisation: { __typename?: 'Organisation', id: string, name: string, type?: string | null, logo?: string | null } } } } | null };\n\nexport type GetExerciseRequestQueryVariables = Exact<{\n  exerciseRequest: Scalars['OptionExerciseRequestCakeType']['input'];\n}>;\n\n\nexport type GetExerciseRequestQuery = { __typename?: 'Query', exerciseRequest?: { __typename?: 'OptionExerciseRequestType', id: string, vestingValue: number, status: EsopOptionExerciseRequestStatusChoices, taxWithholding?: number | null, recipientReference?: string | null, offer?: { __typename?: 'EsopOffer', id: string, currency?: string | null, exercisePrice?: number | null, group: { __typename?: 'EsopOfferGroup', plan: { __typename?: 'Esop', organisation: { __typename?: 'Organisation', id: string, name: string, type?: string | null, country?: string | null, logo?: string | null, optionexerciserequestsettings?: { __typename?: 'OptionExerciseRequestSettingsType', id: string, paymentDetails?: { __typename?: 'PaymentDetailsOutputType', accountName?: string | null, accountNumber?: string | null, routingNumber?: string | null, additionalInstructions?: string | null } | null, exerciseNoticeTemplate: { __typename?: 'Document', id: string } } | null } } } } | null } | null };\n\nexport type ExerciseRequestsFromOfferQueryVariables = Exact<{\n  offerId: Scalars['EsopOfferCakeType']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type ExerciseRequestsFromOfferQuery = { __typename?: 'Query', exerciseRequestsFromOffer?: { __typename?: 'PaginatedOptionExerciseRequestType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'OptionExerciseRequestType', id: string, created: string, status: EsopOptionExerciseRequestStatusChoices, vestingValue: number, taxWithholding?: number | null, recipientReference?: string | null, shareCertificateId?: string | null, offer?: { __typename?: 'EsopOffer', currency?: string | null, id: string, exercisePrice?: number | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null } } | null, exerciseNotice?: { __typename?: 'Document', id: string } | null } | null> | null } | null };\n\nexport type SubmitExercisePaymentMutationVariables = Exact<{\n  exerciseRequestId: Scalars['OptionExerciseRequestCakeType']['input'];\n  signature?: InputMaybe<Scalars['String']['input']>;\n  variant?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type SubmitExercisePaymentMutation = { __typename?: 'Mutation', submitExercisePayment?: boolean | null };\n\nexport type PortfolioOffersListEssFounderVestingQueryVariables = Exact<{\n  employee: Scalars['ShareholderCakeType']['input'];\n}>;\n\n\nexport type PortfolioOffersListEssFounderVestingQuery = { __typename?: 'Query', essOfferList?: Array<{ __typename?: 'EssOffer', id: string, group: { __typename?: 'EssOfferGroup', id: string, country?: string | null, plan: { __typename?: 'Ess', name?: string | null } } } | null> | null, founderVestingOfferList?: Array<{ __typename?: 'FounderVestingOfferOutputType', id: string, group: { __typename?: 'FounderVestingOfferGroupOutputType', id: string, country?: string | null, plan: { __typename?: 'FounderVestingOutputType', name?: string | null } } } | null> | null };\n\nexport type PortfolioOfferDetailsEssFounderVestingQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type PortfolioOfferDetailsEssFounderVestingQuery = { __typename?: 'Query', essOfferDetails?: { __typename?: 'EssOffer', id: string, granted?: number | null, dateGranted?: string | null, vested?: number | null, lapsed?: number | null, loanFunded: boolean, sharePrice?: number | null, shareholder: { __typename?: 'Shareholder', displayName?: string | null, avatar?: string | null }, group: { __typename?: 'EssOfferGroup', country?: string | null, plan: { __typename?: 'Ess', name?: string | null, organisation: { __typename?: 'Organisation', id: string, name: string, currency: OrganisationsOrganisationCurrencyChoices, valuationVisibleToShareholders?: boolean | null, valuationVisibleToOptionholders?: boolean | null, ownershipVisibleToShareholders?: boolean | null, ownershipVisibleToOptionholders?: boolean | null, fullyDilutedShares?: number | null, totalShares?: number | null, totalSharesUnexercised?: number | null, logo?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null } } }, transactionSet: Array<{ __typename?: 'EssTransaction', type: EssEssTransactionTypeChoices, transactionDate: string, vestingValue?: number | null }>, essvestingeventSet: Array<{ __typename?: 'EssVestingEventType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'EssTransaction', id: string, transactionDate: string, vestingValue?: number | null, type: EssEssTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, reminderDate?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null }>, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null, offerLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, planRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, offerLetter?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, planRules?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null } | null, founderVestingOfferDetails?: { __typename?: 'FounderVestingOfferOutputType', id: string, granted?: number | null, dateGranted?: string | null, vested?: number | null, lapsed?: number | null, loanFunded: boolean, sharePrice?: number | null, hasDownloaded83bForm: boolean, shareholder: { __typename?: 'Shareholder', displayName?: string | null, avatar?: string | null }, group: { __typename?: 'FounderVestingOfferGroupOutputType', country?: string | null, plan: { __typename?: 'FounderVestingOutputType', name?: string | null, organisation: { __typename?: 'Organisation', id: string, name: string, currency: OrganisationsOrganisationCurrencyChoices, valuationVisibleToShareholders?: boolean | null, valuationVisibleToOptionholders?: boolean | null, ownershipVisibleToShareholders?: boolean | null, ownershipVisibleToOptionholders?: boolean | null, fullyDilutedShares?: number | null, totalShares?: number | null, totalSharesUnexercised?: number | null, logo?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null } } }, transactionSet: Array<{ __typename?: 'FounderVestingTransactionOutputType', type: FoundervestingFounderVestingTransactionTypeChoices, transactionDate: string, vestingValue?: number | null }>, foundervestingvestingeventSet: Array<{ __typename?: 'FounderVestingVestingEventOutputType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'FounderVestingTransactionOutputType', id: string, transactionDate: string, vestingValue?: number | null, type: FoundervestingFounderVestingTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, reminderDate?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null }>, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null, offerLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, planRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, offerLetter?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, planRules?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null } | null };\n\nexport type PortfolioHomeQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type PortfolioHomeQuery = { __typename?: 'Query', portfolioHome?: Array<{ __typename?: 'PortfolioHomeOutputType', shareholder?: { __typename?: 'Shareholder', id: string, organisation: { __typename?: 'Organisation', id: string, name: string, type?: string | null, country?: string | null, totalShares?: number | null, currency: OrganisationsOrganisationCurrencyChoices, totalSharesUnexercised?: number | null, valuationVisibleToShareholders?: boolean | null, valuationVisibleToOptionholders?: boolean | null, ownershipVisibleToShareholders?: boolean | null, ownershipVisibleToOptionholders?: boolean | null, logo?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null } } | null, groupedShareholdings?: Array<{ __typename?: 'GroupedShareholdingType', totalShares?: number | null, totalInvested?: number | null } | null> | null, groupedShareholdingsInTrust?: Array<{ __typename?: 'GroupedShareholdingInTrustType', totalShares?: number | null, totalInvested?: number | null } | null> | null, groupedNoteholdings?: Array<{ __typename?: 'GroupedNoteholdingType', totalNotes?: number | null, totalInvested?: number | null } | null> | null, groupedPlanData?: Array<{ __typename?: 'PortfolioPlanHoldingOutputType', planType?: VestingPlanType | null, totalVested?: number | null, totalExercised?: number | null, totalLapsed?: number | null, totalGranted?: number | null, vestingNext?: { __typename?: 'VestingCalendarOutputEntry', date?: string | null, vestingValue?: number | null } | null } | null> | null } | null> | null };\n\nexport type PortfolioShareDetailsQueryVariables = Exact<{\n  shareholderId: Scalars['UUID']['input'];\n}>;\n\n\nexport type PortfolioShareDetailsQuery = { __typename?: 'Query', shareholderTransactions?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, organisation: { __typename?: 'Organisation', id: string, name: string, type?: string | null, totalShares?: number | null, totalSharesUnexercised?: number | null, valuationVisibleToShareholders?: boolean | null, valuationVisibleToOptionholders?: boolean | null, ownershipVisibleToShareholders?: boolean | null, ownershipVisibleToOptionholders?: boolean | null, currency: OrganisationsOrganisationCurrencyChoices, country?: string | null, logo?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null }, shareholdings?: Array<{ __typename?: 'ShareholdingType', transactionId?: string | null, transactionDate?: string | null, transactionType?: string | null, shares?: number | null, amount?: number | null, paidInTransfer?: number | null, accumulatedShares?: number | null, unpaid?: number | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null, lastShareCertificate?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null } | null> | null, groupedShareholdings?: Array<{ __typename?: 'GroupedShareholdingType', totalShares?: number | null, totalPaidInIssuance?: number | null, totalUnpaid?: number | null, totalTransferPaid?: number | null, totalTransferReceived?: number | null, sharetype: { __typename?: 'Sharetype', id: string, symbol: string } } | null> | null, groupedBeneficiariesShareholdings?: Array<{ __typename?: 'GroupedShareholdingInTrustType', totalShares?: number | null, totalPaidInIssuance?: number | null, totalUnpaid?: number | null, totalTransferPaid?: number | null, totalTransferReceived?: number | null, beneficiary: { __typename?: 'Shareholder', id: string, displayName?: string | null, hasLoggedIn?: boolean | null }, sharetype: { __typename?: 'Sharetype', name: string, symbol: string } } | null> | null, lastShareCertificate?: { __typename?: 'Document', id: string, name?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null } | null };\n\nexport type PortfolioBeneficialHoldingsDetailsQueryVariables = Exact<{\n  shareholderId: Scalars['UUID']['input'];\n}>;\n\n\nexport type PortfolioBeneficialHoldingsDetailsQuery = { __typename?: 'Query', shareholderTransactions?: { __typename?: 'Shareholder', id: string, displayName?: string | null, organisation: { __typename?: 'Organisation', id: string, name: string, type?: string | null, totalShares?: number | null, totalSharesUnexercised?: number | null, valuationVisibleToShareholders?: boolean | null, valuationVisibleToOptionholders?: boolean | null, ownershipVisibleToShareholders?: boolean | null, ownershipVisibleToOptionholders?: boolean | null, currency: OrganisationsOrganisationCurrencyChoices, country?: string | null, logo?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null }, beneficiaryShareholdings?: Array<{ __typename?: 'ShareholdingType', shareholderId?: string | null, transactionId?: string | null, transactionDate?: string | null, transactionType?: string | null, shares?: number | null, amount?: number | null, paidInTransfer?: number | null, accumulatedShares?: number | null, unpaid?: number | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null } | null> | null, groupedShareholdingsInTrust?: Array<{ __typename?: 'GroupedShareholdingInTrustType', totalShares?: number | null, totalPaidInIssuance?: number | null, totalUnpaid?: number | null, totalTransferPaid?: number | null, totalTransferReceived?: number | null, trustee: { __typename?: 'Shareholder', id: string, displayName?: string | null, trust?: { __typename?: 'TrustType', id: string, name: string } | null }, sharetype: { __typename?: 'Sharetype', id: string, symbol: string } } | null> | null } | null };\n\nexport type PortfolioDetailsQueryVariables = Exact<{\n  shareholderId?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n}>;\n\n\nexport type PortfolioDetailsQuery = { __typename?: 'Query', portfolioHome?: Array<{ __typename?: 'PortfolioHomeOutputType', shareholder?: { __typename?: 'Shareholder', id: string, organisation: { __typename?: 'Organisation', id: string, type?: string | null, country?: string | null, name: string } } | null, shareholdings?: Array<{ __typename?: 'ShareholdingType', transactionId?: string | null } | null> | null, groupedShareholdings?: Array<{ __typename?: 'GroupedShareholdingType', totalShares?: number | null } | null> | null, groupedShareholdingsInTrust?: Array<{ __typename?: 'GroupedShareholdingInTrustType', totalShares?: number | null } | null> | null, groupedNoteholdings?: Array<{ __typename?: 'GroupedNoteholdingType', totalNotes?: number | null } | null> | null, groupedPlanData?: Array<{ __typename?: 'PortfolioPlanHoldingOutputType', planType?: VestingPlanType | null, totalGranted?: number | null } | null> | null } | null> | null };\n\nexport type PortfolioNoteDetailsQueryVariables = Exact<{\n  shareholderId: Scalars['UUID']['input'];\n}>;\n\n\nexport type PortfolioNoteDetailsQuery = { __typename?: 'Query', shareholderTransactions?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, organisation: { __typename?: 'Organisation', id: string, name: string, currency: OrganisationsOrganisationCurrencyChoices, logo?: string | null }, noteholdings?: Array<{ __typename?: 'NoteTransaction', transactionDate: string, type: NotesNoteTransactionTypeChoices, transactionId: string, note: { __typename?: 'Note', id: string, type: NotesNoteTypeChoices, principal?: number | null, interestRate?: number | null, discountRate?: number | null, valuationCap?: number | null, maturityDate?: string | null } } | null> | null, notes?: Array<{ __typename?: 'Note', id: string, type: NotesNoteTypeChoices, principal?: number | null, interestRate?: number | null, discountRate?: number | null, valuationCap?: number | null, maturityDate?: string | null, resolution?: NotesNoteResolutionChoices | null, issueDate: string } | null> | null, groupedNoteholdings?: Array<{ __typename?: 'GroupedNoteholdingType', totalNotes?: number | null, totalInvested?: number | null, notetype?: string | null } | null> | null } | null };\n\nexport type PortfolioOfferDetailsRsuQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type PortfolioOfferDetailsRsuQuery = { __typename?: 'Query', rsuOfferDetails?: { __typename?: 'RsuOfferOutputType', id: string, granted?: number | null, vested?: number | null, lapsed?: number | null, exercised?: number | null, shareholder: { __typename?: 'Shareholder', displayName?: string | null, avatar?: string | null }, group: { __typename?: 'RsuOfferGroupOutputType', country?: string | null, plan: { __typename?: 'RsuOutputType', name?: string | null, organisation: { __typename?: 'Organisation', id: string, name: string, currency: OrganisationsOrganisationCurrencyChoices, valuationVisibleToShareholders?: boolean | null, valuationVisibleToOptionholders?: boolean | null, ownershipVisibleToShareholders?: boolean | null, ownershipVisibleToOptionholders?: boolean | null, fullyDilutedShares?: number | null, totalShares?: number | null, totalSharesUnexercised?: number | null, logo?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null } } }, transactionSet: Array<{ __typename?: 'RsuTransactionOutputType', type: RsuRsuTransactionTypeChoices, transactionDate: string, vestingValue?: number | null }>, rsuvestingeventSet: Array<{ __typename?: 'RsuVestingEventOutputType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'RsuTransactionOutputType', id: string, transactionDate: string, vestingValue?: number | null, type: RsuRsuTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, reminderDate?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null }>, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null, offerLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, planRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, offerLetter?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, planRules?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, conversionlockevent?: { __typename?: 'RsuConversionLockEventOutputType', description: string } | null } | null };\n\nexport type PortfolioOffersListRsuQueryVariables = Exact<{\n  employee: Scalars['ShareholderCakeType']['input'];\n}>;\n\n\nexport type PortfolioOffersListRsuQuery = { __typename?: 'Query', rsuOfferList?: Array<{ __typename?: 'RsuOfferOutputType', id: string, group: { __typename?: 'RsuOfferGroupOutputType', id: string, country?: string | null, plan: { __typename?: 'RsuOutputType', name?: string | null } } } | null> | null };\n\nexport type PortfolioOfferDetailsWarrantQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type PortfolioOfferDetailsWarrantQuery = { __typename?: 'Query', warrantOfferDetails?: { __typename?: 'WarrantOfferOutputType', id: string, granted?: number | null, vested?: number | null, lapsed?: number | null, exercised?: number | null, shareholder: { __typename?: 'Shareholder', displayName?: string | null, avatar?: string | null }, group: { __typename?: 'WarrantOfferGroupOutputType', country?: string | null, plan: { __typename?: 'WarrantOutputType', name?: string | null, organisation: { __typename?: 'Organisation', id: string, name: string, currency: OrganisationsOrganisationCurrencyChoices, valuationVisibleToShareholders?: boolean | null, valuationVisibleToOptionholders?: boolean | null, ownershipVisibleToShareholders?: boolean | null, ownershipVisibleToOptionholders?: boolean | null, fullyDilutedShares?: number | null, totalShares?: number | null, totalSharesUnexercised?: number | null, logo?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null } } }, transactionSet: Array<{ __typename?: 'WarrantTransactionOutputType', type: WarrantWarrantTransactionTypeChoices, transactionDate: string, vestingValue?: number | null }>, warrantvestingeventSet: Array<{ __typename?: 'WarrantVestingEventOutputType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'WarrantTransactionOutputType', id: string, transactionDate: string, vestingValue?: number | null, type: WarrantWarrantTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, reminderDate?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null }>, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null, offerLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, planRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, offerLetter?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null, planRules?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null } | null } | null };\n\nexport type PortfolioOffersListWarrantQueryVariables = Exact<{\n  employee: Scalars['ShareholderCakeType']['input'];\n}>;\n\n\nexport type PortfolioOffersListWarrantQuery = { __typename?: 'Query', warrantOfferList?: Array<{ __typename?: 'WarrantOfferOutputType', id: string, group: { __typename?: 'WarrantOfferGroupOutputType', id: string, country?: string | null, plan: { __typename?: 'WarrantOutputType', name?: string | null } } } | null> | null };\n\nexport type UserProfileQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type UserProfileQuery = { __typename?: 'Query', userProfile?: { __typename?: 'UserType', name?: string | null, email: string, picture: string } | null };\n\nexport type CanChangeEmailQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type CanChangeEmailQuery = { __typename?: 'Query', canChangeEmail?: boolean | null };\n\nexport type UserSettingsQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type UserSettingsQuery = { __typename?: 'Query', userSettings?: { __typename?: 'UserSettingsOutputType', currency: UserAccountsUserSettingsCurrencyChoices } | null };\n\nexport type SkipUserOnboardingMutationVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type SkipUserOnboardingMutation = { __typename?: 'Mutation', skipUserOnboarding?: boolean | null };\n\nexport type RequestEmailChangeMutationVariables = Exact<{\n  newEmail: Scalars['CleanString']['input'];\n}>;\n\n\nexport type RequestEmailChangeMutation = { __typename?: 'Mutation', requestEmailChange?: boolean | null };\n\nexport type UpdateUserOnboardingMutationVariables = Exact<{\n  userBackground: Array<Scalars['CleanString']['input']> | Scalars['CleanString']['input'];\n  intents: Array<Scalars['CleanString']['input']> | Scalars['CleanString']['input'];\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type UpdateUserOnboardingMutation = { __typename?: 'Mutation', updateUserOnboarding?: boolean | null };\n\nexport type UpdateUserSettingsMutationVariables = Exact<{\n  currency: Scalars['CleanString']['input'];\n}>;\n\n\nexport type UpdateUserSettingsMutation = { __typename?: 'Mutation', updateUserSettings?: boolean | null };\n\nexport type AcceptTermsAndConditionsMutationVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type AcceptTermsAndConditionsMutation = { __typename?: 'Mutation', acceptTermsAndConditions?: boolean | null };\n\nexport type ShareholderDetailsQueryVariables = Exact<{\n  shareholderId: Scalars['UUID']['input'];\n}>;\n\n\nexport type ShareholderDetailsQuery = { __typename?: 'Query', shareholder?: { __typename?: 'Shareholder', id: string, computedType?: string | null, heldInTrust?: boolean | null, trustName?: string | null, trustAbn?: string | null, displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, shareholder: { __typename?: 'Shareholder', id: string }, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null } | null } | null };\n\nexport type GetActionsQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n}>;\n\n\nexport type GetActionsQuery = { __typename?: 'Query', actionItems?: { __typename?: 'PaginatedActionItems', count: number, currentPage: number, recent?: number | null, pageData?: Array<{ __typename?: 'ActionItemOutputType', shDisplayName?: string | null, recent?: boolean | null, description?: string | null, link?: string | null, snooze?: boolean | null, itemDate?: string | null, actionableId?: string | null, actionType?: string | null } | null> | null } | null };\n\nexport type GetReminderEmailQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetReminderEmailQuery = { __typename?: 'Query', getReminderEmail?: { __typename?: 'ReminderEmailType', subject?: string | null, body?: string | null, recipientName?: string | null, recipientEmail?: string | null } | null };\n\nexport type RemindAllOffersMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type RemindAllOffersMutation = { __typename?: 'Mutation', remindAllOffers?: Array<string | null> | null };\n\nexport type TouchOffersMutationVariables = Exact<{\n  offers: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n  nudge?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type TouchOffersMutation = { __typename?: 'Mutation', touchOffers?: Array<string | null> | null };\n\nexport type GetActivityLogEntriesQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n  showSupportAdmin?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type GetActivityLogEntriesQuery = { __typename?: 'Query', activityLogContextNames?: Array<Array<string | null> | null> | null, activityLogEntries?: { __typename?: 'PaginatedActivityLogEntryType', currentPage: number, count: number, pageData?: Array<{ __typename?: 'ActivityLogEntryType', timestamp: string, name?: string | null, payload: string, duration: number, supportAdminOnly?: boolean | null, organisation?: { __typename?: 'Organisation', name: string } | null, user?: { __typename?: 'UserType', email: string, name?: string | null, picture: string } | null } | null> | null } | null };\n\nexport type GetInvoicesQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetInvoicesQuery = { __typename?: 'Query', getInvoices?: Array<{ __typename?: 'Invoice', date?: string | null, description?: string | null, total?: number | null, isPaid?: boolean | null, invoice?: string | null, currency?: string | null } | null> | null };\n\nexport type GetLicenseForBillingQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetLicenseForBillingQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', scheduledForDeletion?: string | null, license?: { __typename?: 'LicenseInfoType', overrideDelinquentLock?: boolean | null, esopOfferCount?: number | null, essOfferCount?: number | null, rsuOfferCount?: number | null, warrantOfferCount?: number | null, esopCount?: number | null, essCount?: number | null, rsuCount?: number | null, equityRaiseCount?: number | null, hasEquityPlansEnabled?: boolean | null, internalId?: string | null, maxInvestors?: number | null, investorCount?: number | null, delinquent?: boolean | null, ccLast4?: string | null, globalEsopEnabled?: boolean | null, isPaused: boolean, startDate?: string | null, gtCountries?: Array<string | null> | null, billingEmail?: string | null, billingMobile?: string | null, hasActivePurchased409a?: boolean | null, hasActivePurchasedQsbs?: boolean | null, showExpired409aBanner?: boolean | null, hasScanbotDocuments?: boolean | null, override2faLock?: boolean | null, renewalDate?: string | null, invalidSince?: string | null, subscriptionCancelDate?: string | null } | null, userRoles?: Array<{ __typename?: 'OrganisationUserRoleType', role: OrganisationsOrganisationUserRoleRoleChoices } | null> | null } | null };\n\nexport type GetBillingStakeholdersQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n}>;\n\n\nexport type GetBillingStakeholdersQuery = { __typename?: 'Query', billingStakeholders?: { __typename?: 'PaginatedBillingStakeholder', currentPage: number, count: number, pageData?: Array<{ __typename?: 'BillingStakeholder', id?: string | null, displayName?: string | null, isShareholder?: boolean | null, isBeneficiary?: boolean | null, isNoteholder?: boolean | null, hasActiveEquityRaiseOffer?: boolean | null, hasActiveNotesRaiseOffer?: boolean | null, hasActiveEsopOffer?: boolean | null, hasActiveEssOffer?: boolean | null, hasActiveRsuOffer?: boolean | null } | null> | null } | null };\n\nexport type OverrideDelinquentLockMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  override: Scalars['Boolean']['input'];\n}>;\n\n\nexport type OverrideDelinquentLockMutation = { __typename?: 'Mutation', overrideDelinquentLock?: boolean | null };\n\nexport type ResumeSubscriptionMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type ResumeSubscriptionMutation = { __typename?: 'Mutation', pauseSubscription?: boolean | null };\n\nexport type SendChurnDiscountRequestMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type SendChurnDiscountRequestMutation = { __typename?: 'Mutation', sendChurnDiscountRequest?: boolean | null };\n\nexport type GetPlanNamesEsopQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetPlanNamesEsopQuery = { __typename?: 'Query', esops?: Array<{ __typename?: 'Esop', id: string, name?: string | null } | null> | null };\n\nexport type GetOrganisationBoardMembersDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['Int']['input'];\n  itemsPerPage: Scalars['Int']['input'];\n}>;\n\n\nexport type GetOrganisationBoardMembersDataQuery = { __typename?: 'Query', officeholders?: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, avatar?: string | null, roles: Array<{ __typename?: 'OfficeholderRoleType', role: SeOfficeholderRoleRoleChoices, name?: string | null }> } | null> | null };\n\nexport type CreateBoardApprovalMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  signers: Array<Scalars['OfficeholderCakeType']['input']> | Scalars['OfficeholderCakeType']['input'];\n  esopOffers: Array<Scalars['EsopOfferCakeType']['input']> | Scalars['EsopOfferCakeType']['input'];\n  autoGrant: Scalars['Boolean']['input'];\n}>;\n\n\nexport type CreateBoardApprovalMutation = { __typename?: 'Mutation', createBoardApproval?: { __typename?: 'BoardApprovalType', id: string } | null };\n\nexport type DeleteBoardApprovalMutationVariables = Exact<{\n  boardApproval: Scalars['BoardApprovalCakeType']['input'];\n}>;\n\n\nexport type DeleteBoardApprovalMutation = { __typename?: 'Mutation', deleteBoardApproval?: boolean | null };\n\nexport type SendBoardApprovalReminderMutationVariables = Exact<{\n  boardApproval: Scalars['BoardApprovalCakeType']['input'];\n  signerEmail?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type SendBoardApprovalReminderMutation = { __typename?: 'Mutation', sendBoardApprovalReminder?: boolean | null };\n\nexport type BoardApprovalsQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n}>;\n\n\nexport type BoardApprovalsQuery = { __typename?: 'Query', boardApprovals?: { __typename?: 'PaginatedBoardApprovalType', count: number, pageData?: Array<{ __typename?: 'BoardApprovalType', id: string, created: string, planName?: string | null, status: BoardapprovalsBoardApprovalStatusChoices, signingLink?: string | null, signerName?: string | null, signerEmail?: string | null, signatureId?: string | null, createdBy?: { __typename?: 'UserType', firstName: string, lastName: string } | null, contract?: { __typename?: 'Document', id: string, name?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null } | null> | null } | null, esopOffers?: Array<{ __typename?: 'EsopOfferApprovalItem', id?: string | null, vestStartDate?: string | null, shareholderDisplayName?: string | null, vestingValue?: number | null } | null> | null } | null> | null } | null };\n\nexport type BoardApprovalDetailsQueryVariables = Exact<{\n  boardApproval: Scalars['BoardApprovalCakeType']['input'];\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type BoardApprovalDetailsQuery = { __typename?: 'Query', boardApprovalDetails?: { __typename?: 'BoardApprovalType', id: string, created: string, planName?: string | null, status: BoardapprovalsBoardApprovalStatusChoices, autoGrant: boolean, signingLink?: string | null, signerName?: string | null, signerEmail?: string | null, signatureId?: string | null, createdBy?: { __typename?: 'UserType', firstName: string, lastName: string } | null, contract?: { __typename?: 'Document', id: string, name?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null } | null> | null } | null, esopOffers?: Array<{ __typename?: 'EsopOfferApprovalItem', id?: string | null, vestStartDate?: string | null, shareholderDisplayName?: string | null, vestingValue?: number | null } | null> | null } | null, organisation?: { __typename?: 'Organisation', fullyDilutedShares?: number | null } | null };\n\nexport type GetOrganisationAvailableBoardMembersRolesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetOrganisationAvailableBoardMembersRolesQuery = { __typename?: 'Query', availableOfficeholderRoles?: Array<{ __typename?: 'RoleType', role?: string | null, name?: string | null } | null> | null, availableOrganisationRoles?: { __typename?: 'AvailableOrganisationRoles', roles?: Array<{ __typename?: 'RoleWithDescription', role?: string | null, description?: string | null } | null> | null } | null };\n\nexport type AddOBoardMemberMutationVariables = Exact<{\n  addOfficeholderData: AddOfficeholderData;\n}>;\n\n\nexport type AddOBoardMemberMutation = { __typename?: 'Mutation', addOfficeholder?: { __typename?: 'AddOfficeholder', officeholder?: { __typename?: 'Officeholder', id: string } | null } | null };\n\nexport type GetCommentsQueryVariables = Exact<{\n  instanceId: Scalars['UUID']['input'];\n  modelType: CommentModelTypeEnum;\n}>;\n\n\nexport type GetCommentsQuery = { __typename?: 'Query', getComments?: Array<{ __typename?: 'CommentType', id: string, content: string, created: string, user?: { __typename?: 'UserType', id: string, firstName: string, lastName: string, picture: string } | null } | null> | null };\n\nexport type DeleteCommentMutationVariables = Exact<{\n  commentIds: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n}>;\n\n\nexport type DeleteCommentMutation = { __typename?: 'Mutation', deleteComment?: number | null };\n\nexport type CreateCommentMutationVariables = Exact<{\n  content: Scalars['String']['input'];\n  instanceId: Scalars['UUID']['input'];\n  modelType: CommentModelTypeEnum;\n}>;\n\n\nexport type CreateCommentMutation = { __typename?: 'Mutation', createComment?: boolean | null };\n\nexport type SbcOffersQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  fromDate?: InputMaybe<Scalars['Date']['input']>;\n  toDate?: InputMaybe<Scalars['Date']['input']>;\n}>;\n\n\nexport type SbcOffersQuery = { __typename?: 'Query', sbcOffers?: { __typename?: 'PaginatedAnyOfferType', currentPage: number, count: number, pageData?: Array<\n      | { __typename: 'EsopOffer', optionType?: EsopEsopOfferOptionTypeChoices | null, id: string, dateGranted?: string | null, lastEventDate?: string | null, vestStartDate?: string | null, totalDays?: number | null, totalCliffDays?: number | null, totalPeriodicDays?: number | null, totalGranted?: number | null, calendar?: { __typename?: 'OfferCalendarOutputType', entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, lapsed?: number | null, entryType?: string | null }> | null } | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null } }\n      | { __typename: 'EssOffer', id: string, dateGranted?: string | null, lastEventDate?: string | null, vestStartDate?: string | null, totalDays?: number | null, totalCliffDays?: number | null, totalPeriodicDays?: number | null, totalGranted?: number | null, calendar?: { __typename?: 'OfferCalendarOutputType', entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, lapsed?: number | null, entryType?: string | null }> | null } | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null } }\n      | { __typename: 'RsuOfferOutputType', id: string, dateGranted?: string | null, lastEventDate?: string | null, vestStartDate?: string | null, totalDays?: number | null, totalCliffDays?: number | null, totalPeriodicDays?: number | null, totalGranted?: number | null, calendar?: { __typename?: 'OfferCalendarOutputType', entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, lapsed?: number | null, entryType?: string | null }> | null } | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null } }\n     | null> | null } | null };\n\nexport type SendAsc718RequestMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type SendAsc718RequestMutation = { __typename?: 'Mutation', sendAsc718Request?: boolean | null };\n\nexport type QsbsTransactionsQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  cutoffDate?: InputMaybe<Scalars['Date']['input']>;\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n}>;\n\n\nexport type QsbsTransactionsQuery = { __typename?: 'Query', qsbsTransactions?: { __typename?: 'PaginatedQsbsTransactionType', currentPage: number, count: number, pageData?: Array<{ __typename?: 'QsbsTransactionType', shareholderId?: string | null, displayName?: string | null, transactionId?: string | null, sharetypeName?: string | null, transactionDate?: string | null, qsbsSharesWith83b?: number | null, qsbsSharesWithout83b?: number | null, hasVestingEvent?: boolean | null } | null> | null } | null };\n\nexport type GenerateQsbsReportForTransactionsMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  transactionIds: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n  qsbsForm: QsbsFormInputType;\n}>;\n\n\nexport type GenerateQsbsReportForTransactionsMutation = { __typename?: 'Mutation', generateQsbsReportForTransactions?: boolean | null };\n\nexport type GetDashboardNumberOfStakeholdersQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetDashboardNumberOfStakeholdersQuery = { __typename?: 'Query', dashboardSecurities?: { __typename?: 'DashboardSecurities', numStakeholders?: number | null } | null };\n\nexport type GetDashboardOverviewDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetDashboardOverviewDataQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', logoImage?: string | null } | null };\n\nexport type GetDashboardActionsDataNewQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n}>;\n\n\nexport type GetDashboardActionsDataNewQuery = { __typename?: 'Query', actionItems?: { __typename?: 'PaginatedActionItems', count: number, currentPage: number, recent?: number | null, pageData?: Array<{ __typename?: 'ActionItemOutputType', recent?: boolean | null, description?: string | null, link?: string | null, snooze?: boolean | null, itemDate?: string | null, actionableId?: string | null, actionType?: string | null } | null> | null } | null };\n\nexport type GetDashboardStatisticsQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetDashboardStatisticsQuery = { __typename?: 'Query', dashboardStatistics?: { __typename?: 'DashboardStatistics', numStakeholders?: number | null, totalShares?: number | null, totalSecurities?: number | null, valuation?: number | null, sharetypes?: Array<string | null> | null } | null };\n\nexport type DashboardTopStakeholdersQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  n?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  excludeOthersFromCount?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type DashboardTopStakeholdersQuery = { __typename?: 'Query', dashboardTopStakeholders?: { __typename?: 'DashboardTopStakeholders', dilluted?: Array<{ __typename?: 'DashboardStakeholder', name?: string | null, ownership?: number | null, securities?: number | null, synthetic?: boolean | null } | null> | null, undilluted?: Array<{ __typename?: 'DashboardStakeholder', name?: string | null, ownership?: number | null, securities?: number | null, synthetic?: boolean | null } | null> | null } | null };\n\nexport type GetDashboardSecuritiesQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetDashboardSecuritiesQuery = { __typename?: 'Query', dashboardSecurities?: { __typename?: 'DashboardSecurities', totalShares?: number | null, numShareholders?: number | null, totalOptions?: number | null, numOptionholders?: number | null, totalRsus?: number | null, numRsuholders?: number | null } | null };\n\nexport type GetDashboardKudosQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetDashboardKudosQuery = { __typename?: 'Query', sentKudos?: { __typename?: 'PaginatedSentKudosType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'SentKudosType', id?: string | null, displayName?: string | null, context?: string | null, actionType?: string | null, badge?: string | null, message?: string | null } | null> | null } | null };\n\nexport type DashboardShareholdersPerQuarterQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  numberOfQuarters?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type DashboardShareholdersPerQuarterQuery = { __typename?: 'Query', dashboardShareholdersPerQuarter?: Array<{ __typename?: 'TotalsQuarterEntry', year?: number | null, quarter?: number | null, totalStakeholders?: number | null, totalSecurities?: number | null, newStakeholdersCount?: number | null, newStakeholders?: Array<{ __typename?: 'QuarterlyNewStakeholder', id?: string | null, displayName?: string | null, avatar?: string | null } | null> | null } | null> | null };\n\nexport type DashboardNextVestingEventsQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type DashboardNextVestingEventsQuery = { __typename?: 'Query', dashboardNextVestingEvents?: { __typename?: 'PaginatedNextVestingEvents', count: number, currentPage: number, imminentEventsCount?: number | null, pageData?: Array<{ __typename?: 'NextVestingEventEntry', offerId?: string | null, displayName?: string | null, nextVestingDate?: string | null, nextVestingMeta?: string | null } | null> | null } | null };\n\nexport type DashboardIncentivePlansQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type DashboardIncentivePlansQuery = { __typename?: 'Query', esops?: Array<{ __typename?: 'Esop', name?: string | null, vestingValue?: number | null, totalVested?: number | null, totalLapsed?: number | null, totalOffered?: number | null } | null> | null, rsus?: Array<{ __typename?: 'RsuOutputType', name?: string | null, vestingValue?: number | null, totalVested?: number | null, totalLapsed?: number | null, totalOffered?: number | null } | null> | null, esss?: Array<{ __typename?: 'Ess', name?: string | null, vestingValue?: number | null, totalVested?: number | null, totalLapsed?: number | null, totalOffered?: number | null } | null> | null };\n\nexport type DebugInvalidateShareholdersPerQuarterCacheQueryVariables = Exact<{\n  organisationId: Scalars['String']['input'];\n}>;\n\n\nexport type DebugInvalidateShareholdersPerQuarterCacheQuery = { __typename?: 'Query', debugInvalidateShareholdersPerQuarterCache?: number | null };\n\nexport type EchoPublicQueryVariables = Exact<{\n  echoStr?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type EchoPublicQuery = { __typename?: 'Query', echoPublic?: boolean | null };\n\nexport type EchoPrivateQueryVariables = Exact<{\n  echoStr?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type EchoPrivateQuery = { __typename?: 'Query', echoPrivate?: boolean | null };\n\nexport type DebugClearDailyVestCacheQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type DebugClearDailyVestCacheQuery = { __typename?: 'Query', debugClearDailyVestCache?: boolean | null };\n\nexport type DebugCacheStatisticsQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type DebugCacheStatisticsQuery = { __typename?: 'Query', debugCacheStatistics?: string | null };\n\nexport type DebugInvalidateCacheQueryVariables = Exact<{\n  organisationId: Scalars['String']['input'];\n}>;\n\n\nexport type DebugInvalidateCacheQuery = { __typename?: 'Query', debugInvalidateCache?: number | null };\n\nexport type DebugTriggerEndedDisclosuresQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type DebugTriggerEndedDisclosuresQuery = { __typename?: 'Query', debugTriggerEndedDisclosures?: boolean | null };\n\nexport type DebugInvalidateStripePlanCacheQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type DebugInvalidateStripePlanCacheQuery = { __typename?: 'Query', debugInvalidateStripeTiersAndAddonsCache?: boolean | null };\n\nexport type DebugRefreshLicenseMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type DebugRefreshLicenseMutation = { __typename?: 'Mutation', debugRefreshLicense?: { __typename?: 'LicenseInfoType', internalId?: string | null, hasEquityPlansEnabled?: boolean | null, esopOfferCount?: number | null, essOfferCount?: number | null, rsuOfferCount?: number | null, warrantOfferCount?: number | null, maxInvestors?: number | null, investorCount?: number | null, delinquent?: boolean | null, isPaused: boolean } | null };\n\nexport type DebugReportUsageMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type DebugReportUsageMutation = { __typename?: 'Mutation', debugReportUsage?: boolean | null };\n\nexport type DebugConsolidateCapTableQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type DebugConsolidateCapTableQuery = { __typename?: 'Query', debugConsolidateCapTable?: number | null };\n\nexport type DebugEsopCalendarQueryVariables = Exact<{\n  offer: Scalars['EsopOfferCakeType']['input'];\n  merged?: InputMaybe<Scalars['Boolean']['input']>;\n  sampleEntries?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type DebugEsopCalendarQuery = { __typename?: 'Query', debugEsopCalendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, count?: number | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null };\n\nexport type DebugEssCalendarQueryVariables = Exact<{\n  offer: Scalars['EssOfferCakeType']['input'];\n  merged?: InputMaybe<Scalars['Boolean']['input']>;\n  sampleEntries?: InputMaybe<Scalars['Boolean']['input']>;\n  useLegacy?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type DebugEssCalendarQuery = { __typename?: 'Query', debugEssCalendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, count?: number | null, entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null }> | null } | null };\n\nexport type DebugRefreshExchangeRatesMutationVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type DebugRefreshExchangeRatesMutation = { __typename?: 'Mutation', debugRefreshExchangeRates?: boolean | null };\n\nexport type GetDocumentQueryVariables = Exact<{\n  documentId: Scalars['DocumentCakeType']['input'];\n}>;\n\n\nexport type GetDocumentQuery = { __typename?: 'Query', document?: { __typename?: 'Document', id: string, name?: string | null, modified: string, extension?: string | null, type: DocumentsDocumentTypeChoices, status?: string | null, contractType?: string | null, signatureEmailSubject?: string | null, signatureEmailBody?: string | null, signingEnvelopeId?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null, extra?: string | null } | null> | null, access?: Array<{ __typename?: 'DocumentAccessType', id?: string | null, isShareholder?: boolean | null, name?: string | null, email?: string | null, avatar?: string | null, isDirectPermission?: boolean | null } | null> | null } | null };\n\nexport type GetFolderPathQueryVariables = Exact<{\n  documentId: Scalars['DocumentCakeType']['input'];\n}>;\n\n\nexport type GetFolderPathQuery = { __typename?: 'Query', document?: { __typename?: 'Document', path?: Array<{ __typename?: 'Document', id: string, name?: string | null, fileCount?: number | null, folderCount?: number | null, isSystem: boolean } | null> | null } | null };\n\nexport type ListFoldersQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  documentId: Scalars['UUID']['input'];\n}>;\n\n\nexport type ListFoldersQuery = { __typename?: 'Query', listFolders?: Array<{ __typename?: 'Document', id: string, name?: string | null, fileCount?: number | null, folderCount?: number | null, isSystem: boolean } | null> | null };\n\nexport type ListFilesQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  documentId: Scalars['UUID']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type ListFilesQuery = { __typename?: 'Query', listFiles?: { __typename?: 'PaginatedDocuments', currentPage: number, count: number, pageData?: Array<{ __typename?: 'Document', id: string, name?: string | null, extension?: string | null, modified: string, parent?: { __typename?: 'Document', name?: string | null } | null } | null> | null } | null };\n\nexport type GetOrganisationDocumentsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  filterType?: InputMaybe<Scalars['String']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetOrganisationDocumentsQuery = { __typename?: 'Query', organisationDocuments?: { __typename?: 'PaginatedDocuments', currentPage: number, count: number, pageData?: Array<{ __typename?: 'Document', id: string, modified: string, name?: string | null, extension?: string | null, contractType?: string | null, usedIn?: Array<string | null> | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null } | null> | null, parent?: { __typename?: 'Document', name?: string | null } | null } | null> | null } | null };\n\nexport type GetDocumentPermissionsQueryVariables = Exact<{\n  documentId: Scalars['DocumentCakeType']['input'];\n}>;\n\n\nexport type GetDocumentPermissionsQuery = { __typename?: 'Query', document?: { __typename?: 'Document', id: string, created: string, modified: string, name?: string | null, file?: string | null, extension?: string | null, access?: Array<{ __typename?: 'DocumentAccessType', id?: string | null, isShareholder?: boolean | null, name?: string | null, email?: string | null, avatar?: string | null, isDirectPermission?: boolean | null } | null> | null } | null };\n\nexport type TemplatesByContractTypeQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  contractTypes: Array<Scalars['CleanString']['input']> | Scalars['CleanString']['input'];\n  country?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type TemplatesByContractTypeQuery = { __typename?: 'Query', templatesByContractType?: Array<{ __typename?: 'Document', id: string, name?: string | null, updated: string } | null> | null };\n\nexport type TemplateViewLinkQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  organisationId: Scalars['UUID']['input'];\n  contractType: Scalars['CleanString']['input'];\n}>;\n\n\nexport type TemplateViewLinkQuery = { __typename?: 'Query', templateViewLink?: string | null, organisation?: { __typename?: 'Organisation', shareCertificateType: OrganisationsOrganisationShareCertificateTypeChoices } | null };\n\nexport type AvailableTemplateTypesQueryVariables = Exact<{\n  countryCode: Scalars['CleanString']['input'];\n}>;\n\n\nexport type AvailableTemplateTypesQuery = { __typename?: 'Query', availableTemplateTypes?: Array<string | null> | null };\n\nexport type GetContractLinkQueryVariables = Exact<{\n  documentId: Scalars['DocumentCakeType']['input'];\n}>;\n\n\nexport type GetContractLinkQuery = { __typename?: 'Query', document?: { __typename?: 'Document', id: string, contractLink?: string | null } | null };\n\nexport type GetDocumentMinimalQueryVariables = Exact<{\n  documentId: Scalars['DocumentCakeType']['input'];\n}>;\n\n\nexport type GetDocumentMinimalQuery = { __typename?: 'Query', document?: { __typename?: 'Document', id: string, name?: string | null, extension?: string | null, contractType?: string | null, signingEnvelopeId?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null } | null> | null } | null };\n\nexport type CreateFolderMutationVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  names: Array<InputMaybe<Scalars['String']['input']>> | InputMaybe<Scalars['String']['input']>;\n  parentId?: InputMaybe<Scalars['String']['input']>;\n  useExisting?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type CreateFolderMutation = { __typename?: 'Mutation', createFolder?: { __typename?: 'CreateFolder', folders?: Array<{ __typename?: 'Document', id: string, name?: string | null } | null> | null } | null };\n\nexport type CopyMoveFileOrFolderMutationVariables = Exact<{\n  sourceIds: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n  destinationId?: InputMaybe<Scalars['UUID']['input']>;\n  isMove?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type CopyMoveFileOrFolderMutation = { __typename?: 'Mutation', copyMoveFileOrFolder?: { __typename?: 'CopyMoveFileOrFolder', ok?: boolean | null } | null };\n\nexport type ShareDocumentMutationVariables = Exact<{\n  shareholderOrGroupId: Scalars['UUID']['input'];\n  documentId: Scalars['UUID']['input'];\n}>;\n\n\nexport type ShareDocumentMutation = { __typename?: 'Mutation', shareDocument?: { __typename?: 'ShareDocument', ok?: boolean | null } | null };\n\nexport type RemoveShareDocumentMutationVariables = Exact<{\n  shareholderOrGroupId: Scalars['UUID']['input'];\n  documentId: Scalars['UUID']['input'];\n}>;\n\n\nexport type RemoveShareDocumentMutation = { __typename?: 'Mutation', removeShareDocument?: { __typename?: 'RemoveShareDocument', ok?: boolean | null } | null };\n\nexport type DeleteDocumentMutationVariables = Exact<{\n  documents: Array<Scalars['DocumentCakeType']['input']> | Scalars['DocumentCakeType']['input'];\n}>;\n\n\nexport type DeleteDocumentMutation = { __typename?: 'Mutation', deleteDocument?: { __typename?: 'DeleteDocument', ok?: boolean | null } | null };\n\nexport type RenameDocumentMutationVariables = Exact<{\n  documentId: Scalars['UUID']['input'];\n  newName: Scalars['String']['input'];\n}>;\n\n\nexport type RenameDocumentMutation = { __typename?: 'Mutation', renameDocument?: { __typename?: 'RenameDocument', ok?: boolean | null } | null };\n\nexport type GenerateShareCertificatesFromHoldingsMutationVariables = Exact<{\n  shareholderIds: Array<InputMaybe<Scalars['ShareholderCakeType']['input']>> | InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  certificateNumber: Scalars['Int']['input'];\n  selectionOrganisationId?: InputMaybe<Scalars['OrganisationCakeType']['input']>;\n  selectionSearch?: InputMaybe<Scalars['String']['input']>;\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  notifyShareholder?: InputMaybe<Scalars['Boolean']['input']>;\n  disclaimersBySharetype?: InputMaybe<Array<SharetypeDisclaimerInputType> | SharetypeDisclaimerInputType>;\n}>;\n\n\nexport type GenerateShareCertificatesFromHoldingsMutation = { __typename?: 'Mutation', generateShareCertificatesFromHoldings?: { __typename?: 'GenerateShareCertificates', lastCertificateNumber?: number | null } | null };\n\nexport type GenerateShareCertificateByCriteriaMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  certificateNumber: Scalars['Int']['input'];\n  filterDate?: InputMaybe<Scalars['Date']['input']>;\n  filterDateIsGte?: InputMaybe<Scalars['Boolean']['input']>;\n  filterShareType?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  notifyShareholder?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type GenerateShareCertificateByCriteriaMutation = { __typename?: 'Mutation', generateShareCertificateByCriteria?: number | null };\n\nexport type FinaliseTemplateMutationVariables = Exact<{\n  document: Scalars['DocumentCakeType']['input'];\n  revert?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type FinaliseTemplateMutation = { __typename?: 'Mutation', finaliseTemplate?: { __typename?: 'FinaliseTemplate', ok?: boolean | null } | null };\n\nexport type MoveFromSigningToDocumentsMutationVariables = Exact<{\n  documentId: Scalars['UUID']['input'];\n  folder: Scalars['String']['input'];\n}>;\n\n\nexport type MoveFromSigningToDocumentsMutation = { __typename?: 'Mutation', moveFromSigningToDocuments?: { __typename?: 'MoveFromSigningToDocuments', ok?: boolean | null } | null };\n\nexport type StartContractSigningMutationVariables = Exact<{\n  document: Scalars['DocumentCakeType']['input'];\n  emailSubject: Scalars['CleanString']['input'];\n  emailBody: Scalars['CleanString']['input'];\n  shareholderSigners?: InputMaybe<Array<Scalars['ShareholderCakeType']['input']> | Scalars['ShareholderCakeType']['input']>;\n  officeholderSigners?: InputMaybe<Array<Scalars['OfficeholderCakeType']['input']> | Scalars['OfficeholderCakeType']['input']>;\n  userSigners?: InputMaybe<Array<Scalars['UserCakeType']['input']> | Scalars['UserCakeType']['input']>;\n  groupSigners?: InputMaybe<Array<Scalars['CakeGroupCakeType']['input']> | Scalars['CakeGroupCakeType']['input']>;\n}>;\n\n\nexport type StartContractSigningMutation = { __typename?: 'Mutation', startContractSigning?: { __typename?: 'StartContractSigning', ok?: boolean | null } | null };\n\nexport type CreateDraftContractMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  contractType: Scalars['String']['input'];\n  documentName: Scalars['String']['input'];\n}>;\n\n\nexport type CreateDraftContractMutation = { __typename?: 'Mutation', createDraftContract?: { __typename?: 'CreateDraftContract', ok?: boolean | null } | null };\n\nexport type FixContractTemplatePlaceholdersMutationVariables = Exact<{\n  document: Scalars['DocumentCakeType']['input'];\n}>;\n\n\nexport type FixContractTemplatePlaceholdersMutation = { __typename?: 'Mutation', fixContractTemplatePlaceholders?: boolean | null };\n\nexport type SyncWithMasterTemplateMutationVariables = Exact<{\n  document: Scalars['DocumentCakeType']['input'];\n}>;\n\n\nexport type SyncWithMasterTemplateMutation = { __typename?: 'Mutation', syncWithMasterTemplate?: boolean | null };\n\nexport type GenerateTransactionalShareCertificateMutationVariables = Exact<{\n  transactionId: Scalars['ShareholdingTransactionCakeType']['input'];\n  certificateNumber: Scalars['PositiveInteger']['input'];\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  disclaimerBySharetype?: InputMaybe<SharetypeDisclaimerInputType>;\n}>;\n\n\nexport type GenerateTransactionalShareCertificateMutation = { __typename?: 'Mutation', generateTransactionalShareCertificate?: number | null };\n\nexport type UploadToScanbotMutationVariables = Exact<{\n  document: Scalars['DocumentCakeType']['input'];\n}>;\n\n\nexport type UploadToScanbotMutation = { __typename?: 'Mutation', uploadToScanbot?: { __typename?: 'ScanbotDocumentType', id: string } | null };\n\nexport type GetTemplatesByContractTypeQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  country?: InputMaybe<Scalars['CleanString']['input']>;\n  contractTypes: Array<Scalars['CleanString']['input']> | Scalars['CleanString']['input'];\n}>;\n\n\nexport type GetTemplatesByContractTypeQuery = { __typename?: 'Query', templatesByContractType?: Array<{ __typename?: 'Document', id: string, name?: string | null, contractLink?: string | null, contractProvider?: string | null, contractType?: string | null, created: string, updated: string } | null> | null };\n\nexport type GetPlanToEditEsopQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  planId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetPlanToEditEsopQuery = { __typename?: 'Query', plan?: Array<{ __typename?: 'Esop', id: string, name?: string | null, vestingValue?: number | null, optionPrice?: number | null, requireWitness: boolean, totalVested?: number | null, totalExercised?: number | null, totalOffered?: number | null, organisation: { __typename?: 'Organisation', id: string, fullyDilutedShares?: number | null, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null }, group?: Array<{ __typename?: 'EsopOfferGroup', id: string, country?: string | null, exercisePrice?: number | null, restrictionsOnShares?: Array<string> | null, allowNomineeTrust: boolean, requireBoardApproval: boolean, disclosurePeriodDays: number, isEditable?: boolean | null, currency?: string | null, optionPrice?: number | null, groupCurrency?: string | null, allowEarlyExercise: boolean, sendExpirationNotification?: boolean | null, autoLapseOnExpirationDate?: boolean | null, exerciseExpirationStartingPoint?: string | null, exerciseExpireTime?: { __typename?: 'TimeSliceType', quantity?: number | null, unit?: string | null } | null, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null, ptepSettings?: { __typename?: 'PtepSettingsOutputType', ptepInterval: { __typename?: 'TimeSliceType', quantity?: number | null, unit?: string | null } } | null } | null> | null } | null> | null, sharetypes?: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string } | null> | null };\n\nexport type GetPlanOfferToEditOptionPriceEsopQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n}>;\n\n\nexport type GetPlanOfferToEditOptionPriceEsopQuery = { __typename?: 'Query', offer?: { __typename?: 'EsopOffer', id: string, created: string, modified: string, currency?: string | null, country?: string | null, optionPrice?: number | null, plan?: { __typename?: 'Esop', group?: Array<{ __typename?: 'EsopOfferGroup', optionPrice?: number | null } | null> | null } | null } | null, checkOffersEditability?: { __typename?: 'PaginatedPostGrantEditabilityType', pageData?: Array<{ __typename?: 'PostGrantEditabilityType', offerId?: string | null, canEdit?: boolean | null, reasons?: Array<string | null> | null } | null> | null } | null };\n\nexport type GetPlanOfferToEditExercisePriceEsopQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n}>;\n\n\nexport type GetPlanOfferToEditExercisePriceEsopQuery = { __typename?: 'Query', offer?: { __typename?: 'EsopOffer', id: string, created: string, modified: string, currency?: string | null, country?: string | null, exercisePrice?: number | null, plan?: { __typename?: 'Esop', group?: Array<{ __typename?: 'EsopOfferGroup', exercisePrice?: number | null } | null> | null } | null } | null, checkOffersEditability?: { __typename?: 'PaginatedPostGrantEditabilityType', pageData?: Array<{ __typename?: 'PostGrantEditabilityType', offerId?: string | null, canEdit?: boolean | null, reasons?: Array<string | null> | null } | null> | null } | null };\n\nexport type GetPlanOfferToEditGrantDateEsopQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n}>;\n\n\nexport type GetPlanOfferToEditGrantDateEsopQuery = { __typename?: 'Query', offer?: { __typename?: 'EsopOffer', id: string, created: string, modified: string, grantDateDefault?: string | null, dateGranted?: string | null } | null, checkOffersEditability?: { __typename?: 'PaginatedPostGrantEditabilityType', pageData?: Array<{ __typename?: 'PostGrantEditabilityType', offerId?: string | null, canEdit?: boolean | null, reasons?: Array<string | null> | null } | null> | null } | null };\n\nexport type GetPlanOfferToEditExpireDateEsopQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetPlanOfferToEditExpireDateEsopQuery = { __typename?: 'Query', offer?: { __typename?: 'EsopOffer', id: string, created: string, modified: string, exerciseExpireDate?: string | null, exerciseExpirationStartingPoint?: EsopEsopOfferExerciseExpirationStartingPointChoices | null, sendExpirationNotification?: boolean | null, autoLapseOnExpirationDate?: boolean | null, exerciseExpireTime?: { __typename?: 'TimeSliceType', quantity?: number | null, unit?: string | null } | null } | null };\n\nexport type GetPlanOfferToEditVestingEventsEsopQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetPlanOfferToEditVestingEventsEsopQuery = { __typename?: 'Query', offer?: { __typename?: 'EsopOffer', id: string, created: string, modified: string, vestStartDate?: string | null, group: { __typename?: 'EsopOfferGroup', plan: { __typename?: 'Esop', organisation: { __typename?: 'Organisation', type?: string | null } } }, vestingEvents?: Array<{ __typename?: 'EsopVestingEventType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'EsopTransaction', id: string }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null } | null };\n\nexport type CheckOffersPostGrantGrantDateEditabilityEsopQueryVariables = Exact<{\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n  plan: Scalars['EsopCakeType']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n}>;\n\n\nexport type CheckOffersPostGrantGrantDateEditabilityEsopQuery = { __typename?: 'Query', checkOffersEditability?: { __typename?: 'PaginatedPostGrantEditabilityType', currentPage: number, count: number, uneditableCount?: number | null, pageData?: Array<{ __typename?: 'PostGrantEditabilityType', offerId?: string | null, displayName?: string | null, email?: string | null, avatar?: string | null, canEdit?: boolean | null, reasons?: Array<string | null> | null } | null> | null } | null };\n\nexport type CheckOffersPostGrantOptionPriceEditabilityEsopQueryVariables = Exact<{\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n  plan: Scalars['EsopCakeType']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n}>;\n\n\nexport type CheckOffersPostGrantOptionPriceEditabilityEsopQuery = { __typename?: 'Query', checkOffersEditability?: { __typename?: 'PaginatedPostGrantEditabilityType', currentPage: number, count: number, uneditableCount?: number | null, pageData?: Array<{ __typename?: 'PostGrantEditabilityType', offerId?: string | null, displayName?: string | null, email?: string | null, avatar?: string | null, canEdit?: boolean | null, reasons?: Array<string | null> | null } | null> | null } | null };\n\nexport type CheckOffersPostGrantExercisePriceEditabilityEsopQueryVariables = Exact<{\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n  plan: Scalars['EsopCakeType']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n}>;\n\n\nexport type CheckOffersPostGrantExercisePriceEditabilityEsopQuery = { __typename?: 'Query', checkOffersEditability?: { __typename?: 'PaginatedPostGrantEditabilityType', currentPage: number, count: number, uneditableCount?: number | null, pageData?: Array<{ __typename?: 'PostGrantEditabilityType', offerId?: string | null, displayName?: string | null, email?: string | null, avatar?: string | null, canEdit?: boolean | null, reasons?: Array<string | null> | null } | null> | null } | null };\n\nexport type CheckOffersPostGrantExpirationEditabilityEsopQueryVariables = Exact<{\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n  plan: Scalars['EsopCakeType']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  expirationData: OfferExerciseExpirationDataInputType;\n}>;\n\n\nexport type CheckOffersPostGrantExpirationEditabilityEsopQuery = { __typename?: 'Query', checkOffersEditability?: { __typename?: 'PaginatedPostGrantEditabilityType', currentPage: number, count: number, uneditableCount?: number | null, pageData?: Array<{ __typename?: 'PostGrantEditabilityType', offerId?: string | null, displayName?: string | null, email?: string | null, avatar?: string | null, canEdit?: boolean | null, reasons?: Array<string | null> | null } | null> | null } | null };\n\nexport type CheckOffersBulkPostGrantPtepEditabilityEsopQueryVariables = Exact<{\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n  plan: Scalars['EsopCakeType']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n}>;\n\n\nexport type CheckOffersBulkPostGrantPtepEditabilityEsopQuery = { __typename?: 'Query', checkOffersEditability?: { __typename?: 'PaginatedPostGrantEditabilityType', currentPage: number, count: number, uneditableCount?: number | null, pageData?: Array<{ __typename?: 'PostGrantEditabilityType', offerId?: string | null, displayName?: string | null, email?: string | null, avatar?: string | null, canEdit?: boolean | null, reasons?: Array<string | null> | null } | null> | null } | null };\n\nexport type CheckOfferPostGrantPtepEditabilityEsopQueryVariables = Exact<{\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  offerId: Scalars['UUID']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n  offerGroup?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n}>;\n\n\nexport type CheckOfferPostGrantPtepEditabilityEsopQuery = { __typename?: 'Query', checkOffersEditability?: { __typename?: 'PaginatedPostGrantEditabilityType', currentPage: number, count: number, uneditableCount?: number | null, pageData?: Array<{ __typename?: 'PostGrantEditabilityType', offerId?: string | null, displayName?: string | null, email?: string | null, avatar?: string | null, canEdit?: boolean | null, reasons?: Array<string | null> | null } | null> | null } | null, offer?: { __typename?: 'EsopOffer', id: string, ptepSettings?: { __typename?: 'PtepSettingsOutputType', ptepInterval: { __typename?: 'TimeSliceType', quantity?: number | null, unit?: string | null } } | null } | null };\n\nexport type EditPostGrantDateEsopMutationVariables = Exact<{\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n  grantDate: Scalars['Date']['input'];\n  planType: Scalars['EsopCakeType']['input'];\n  group?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>>;\n}>;\n\n\nexport type EditPostGrantDateEsopMutation = { __typename?: 'Mutation', editPostGrantGrantDateEsop?: boolean | null };\n\nexport type EditPostVestDateEsopMutationVariables = Exact<{\n  offer: Scalars['EsopOfferCakeType']['input'];\n  vestStartDate: Scalars['Date']['input'];\n}>;\n\n\nexport type EditPostVestDateEsopMutation = { __typename?: 'Mutation', editPostGrantVestStartDateEsop?: boolean | null };\n\nexport type EditPostGrantOptionPriceEsopMutationVariables = Exact<{\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n  optionPrice: Scalars['CakeDecimal']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n  group?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>>;\n}>;\n\n\nexport type EditPostGrantOptionPriceEsopMutation = { __typename?: 'Mutation', editPostGrantOptionPriceEsop?: boolean | null };\n\nexport type EditPostGrantExercisePriceEsopMutationVariables = Exact<{\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n  exercisePrice: Scalars['CakeDecimal']['input'];\n  plan: Scalars['EsopCakeType']['input'];\n  group?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>>;\n  attachment?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  repriceTransactionDate?: InputMaybe<Scalars['Date']['input']>;\n}>;\n\n\nexport type EditPostGrantExercisePriceEsopMutation = { __typename?: 'Mutation', editPostGrantExercisePriceEsop?: boolean | null };\n\nexport type EditPostGrantExpirationEsopMutationVariables = Exact<{\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n  exerciseExpirationData: OfferExerciseExpirationDataInputType;\n  plan: Scalars['EsopCakeType']['input'];\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>>;\n}>;\n\n\nexport type EditPostGrantExpirationEsopMutation = { __typename?: 'Mutation', editPostGrantExpirationEsop?: boolean | null };\n\nexport type EditPostGrantPtepEsopMutationVariables = Exact<{\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n  ptep?: InputMaybe<TimeSliceInputType>;\n  plan: Scalars['EsopCakeType']['input'];\n  group?: InputMaybe<Scalars['EsopOfferGroupCakeType']['input']>;\n  excludeIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>>;\n}>;\n\n\nexport type EditPostGrantPtepEsopMutation = { __typename?: 'Mutation', editPostGrantPtepEsop?: boolean | null };\n\nexport type EditEsopMutationVariables = Exact<{\n  plan: Scalars['EsopCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  vestingValue: Scalars['PositiveInteger']['input'];\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type EditEsopMutation = { __typename?: 'Mutation', editEsop?: boolean | null };\n\nexport type EditGroupAndEsopMutationVariables = Exact<{\n  plan: Scalars['EsopCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  vestingValue: Scalars['PositiveInteger']['input'];\n  group: Scalars['EsopOfferGroupCakeType']['input'];\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  enforceDisclosurePeriod?: InputMaybe<Scalars['Boolean']['input']>;\n  optionPrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  exercisePrice?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  restrictionsOnShares?: InputMaybe<Array<InputMaybe<Scalars['CleanString']['input']>> | InputMaybe<Scalars['CleanString']['input']>>;\n  useGroupCurrency?: InputMaybe<Scalars['Boolean']['input']>;\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n  postTerminationExercisePeriod?: InputMaybe<TimeSliceInputType>;\n  exerciseExpireData?: InputMaybe<ExerciseExpireDataInputType>;\n  allowEarlyExercise?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type EditGroupAndEsopMutation = { __typename?: 'Mutation', editEsop?: boolean | null, editGroupEsop?: boolean | null };\n\nexport type DeleteEsopMutationVariables = Exact<{\n  plan: Scalars['EsopCakeType']['input'];\n}>;\n\n\nexport type DeleteEsopMutation = { __typename?: 'Mutation', deleteEsop?: boolean | null };\n\nexport type GetDataToLapseOfferEsopQueryVariables = Exact<{\n  offer: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetDataToLapseOfferEsopQuery = { __typename?: 'Query', lapseData?: { __typename?: 'EsopOffer', id: string, vestStartDate?: string | null, softStatus?: string | null, granted?: number | null, vestablePeriodic?: number | null, lapsed?: number | null, lapsedPeriodic?: number | null, exercised?: number | null, vestedMilestone?: number | null, lapsedMilestone?: number | null, vestableMilestone?: number | null, availableToPeriodicVest?: number | null, availableToVestMilestone?: number | null, availableToLapse?: number | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null }, calendar?: { __typename?: 'OfferCalendarOutputType', entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, entryType?: string | null }> | null } | null, vestingEvents?: Array<{ __typename?: 'EsopVestingEventType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'EsopTransaction', id: string, transactionDate: string, vestingValue?: number | null, type: EsopEsopTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null } | null } | null> | null } | null };\n\nexport type GetOffersEligibleForApprovalEsopQueryVariables = Exact<{\n  esop: Scalars['EsopCakeType']['input'];\n}>;\n\n\nexport type GetOffersEligibleForApprovalEsopQuery = { __typename?: 'Query', esopOffersEligibleForApproval?: Array<{ __typename?: 'EsopOfferApprovalItem', id?: string | null, vestStartDate?: string | null, shareholderDisplayName?: string | null, vestingValue?: number | null } | null> | null };\n\nexport type LapseOfferMilestoneEsopMutationVariables = Exact<{\n  offer: Scalars['EsopOfferCakeType']['input'];\n  lapseDate: Scalars['Date']['input'];\n  milestoneEvents: Array<LapseMilestoneEntryInputType> | LapseMilestoneEntryInputType;\n}>;\n\n\nexport type LapseOfferMilestoneEsopMutation = { __typename?: 'Mutation', lapseMilestoneEsop?: boolean | null };\n\nexport type LapseOfferEsopMutationVariables = Exact<{\n  offer: Scalars['EsopOfferCakeType']['input'];\n  lapseDate: Scalars['Date']['input'];\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n}>;\n\n\nexport type LapseOfferEsopMutation = { __typename?: 'Mutation', lapseOfferEsop?: boolean | null };\n\nexport type FullyLapseOfferEsopMutationVariables = Exact<{\n  offer: Scalars['EsopOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n}>;\n\n\nexport type FullyLapseOfferEsopMutation = { __typename?: 'Mutation', fullyLapseOfferEsop?: boolean | null };\n\nexport type AssignBareTrustEsopMutationVariables = Exact<{\n  offers: Scalars['EsopOfferQuerySetCakeType']['input'];\n  bareTrustTrustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n}>;\n\n\nexport type AssignBareTrustEsopMutation = { __typename?: 'Mutation', assignBareTrustEsop?: number | null };\n\nexport type GetPlansEsopQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetPlansEsopQuery = { __typename?: 'Query', plans?: Array<{ __typename?: 'Esop', id: string, name?: string | null, vestingValue?: number | null, totalExercised?: number | null, totalVested?: number | null, totalLapsed?: number | null, totalOffered?: number | null, group?: Array<{ __typename?: 'EsopOfferGroup', country?: string | null } | null> | null } | null> | null, organisation?: { __typename?: 'Organisation', fullyDilutedShares?: number | null } | null };\n\nexport type GetPlanEsopQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  esopId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetPlanEsopQuery = { __typename?: 'Query', plan?: Array<{ __typename?: 'Esop', id: string, name?: string | null, vestingValue?: number | null, commentCount?: number | null, optionPrice?: number | null, requireWitness: boolean, totalVested?: number | null, totalExercised?: number | null, totalLapsed?: number | null, totalGranted?: number | null, totalOffered?: number | null, organisation: { __typename?: 'Organisation', id: string, created: string, fullyDilutedShares?: number | null, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null }, documents?: Array<{ __typename?: 'Document', id: string, created: string, name?: string | null, file?: string | null, extension?: string | null } | null> | null, group?: Array<{ __typename?: 'EsopOfferGroup', id: string, country?: string | null, offerCount?: number | null, offerAcceptedCount?: number | null, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null, defaultPlanRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null, defaultOfferLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null, planRulesTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices }>, offerLetterTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices }>, directorsResolution?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null, extra?: string | null } | null> | null } | null, directorsResolutionTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null, shareholdersResolution?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null, extra?: string | null } | null> | null } | null, shareholdersResolutionTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null } | null> | null } | null> | null };\n\nexport type GetPlanGroupEsopQueryVariables = Exact<{\n  groupId: Scalars['EsopOfferGroupCakeType']['input'];\n}>;\n\n\nexport type GetPlanGroupEsopQuery = { __typename?: 'Query', group?: { __typename?: 'EsopOfferGroup', id: string, country?: string | null, optionPrice?: number | null, exercisePrice?: number | null, valueOfClassOfShare?: number | null, restrictionsOnShares?: Array<string> | null, totalGranted?: number | null, totalVested?: number | null, totalLapsed?: number | null, totalExercised?: number | null, totalOffered?: number | null, offerCount?: number | null, offerAcceptedCount?: number | null, allowNomineeTrust: boolean, disclosurePeriodDays: number, isEditable?: boolean | null, currency?: string | null, groupCurrency?: string | null, exerciseExpireTime?: { __typename?: 'TimeSliceType', quantity?: number | null, unit?: string | null } | null, offerLetterTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, modified: string }>, planRulesTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null, modified: string }>, shareholdersResolutionTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, modified: string } | null, shareholdersResolution?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null, extra?: string | null } | null> | null } | null, directorsResolutionTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, modified: string } | null, directorsResolution?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null, extra?: string | null } | null> | null } | null, plan: { __typename?: 'Esop', id: string, name?: string | null }, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } | null };\n\nexport type GetPlanOffersToCompleteEsopQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n}>;\n\n\nexport type GetPlanOffersToCompleteEsopQuery = { __typename?: 'Query', offers?: Array<{ __typename?: 'EsopOffer', id: string, vestStartDate?: string | null, country?: string | null, exercisePrice?: number | null, status?: string | null, softStatus?: string | null, optionType?: EsopEsopOfferOptionTypeChoices | null, shareholderDisplayName?: string | null, shareholder?: { __typename?: 'Shareholder', id: string, secondaryName?: string | null, avatar?: string | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null } | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, jointIndex: number, companyData?: { __typename?: 'CompanyDataType', signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null } | null> | null } | null } | null> | null } | null, offerLetterTemplate?: { __typename?: 'Document', id: string } | null, group: { __typename?: 'EsopOfferGroup', id: string, country?: string | null, restrictionsOnShares?: Array<string> | null, allowNomineeTrust: boolean, currency?: string | null, offerLetterTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, status?: string | null, contractType?: string | null, modified: string }>, planRulesTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, modified: string, extension?: string | null }>, defaultPlanRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null, defaultOfferLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null } } | null> | null };\n\nexport type GetPlanOffersEsopQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  filterId: Scalars['UUID']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  filters?: InputMaybe<Array<ListFilterType> | ListFilterType>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']> | Scalars['CleanString']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type GetPlanOffersEsopQuery = { __typename?: 'Query', offers?: { __typename?: 'PaginatedEsopOffer', count: number, currentPage: number, notSignedUpCount?: number | null, shareholderCount?: number | null, plan?: { __typename?: 'Esop', id: string, vestingValue?: number | null, totalOffered?: number | null, totalLapsed?: number | null, organisation: { __typename?: 'Organisation', fullyDilutedShares?: number | null } } | null, pageData?: Array<{ __typename?: 'ListContextVestingOfferType', id?: string | null, modified?: string | null, groupId?: string | null, planId?: string | null, offerLetterId?: string | null, boardApprovalId?: string | null, dateGranted?: string | null, vestStartDate?: string | null, emailsOn?: boolean | null, requireWitness?: boolean | null, shareholderId?: string | null, shareholderDisplayName?: string | null, shareholderSecondaryName?: string | null, shareholderAvatar?: string | null, shareholderHasLoggedIn?: boolean | null, shareholderConsideredInvited?: boolean | null, shEmail?: string | null, status?: string | null, softStatus?: string | null, country?: string | null, vestingValue?: number | null, availableToLapse?: number | null, availableToExercise?: number | null, availableToVest?: number | null, vested?: number | null, granted?: number | null, lapsed?: number | null, exercised?: number | null, hasOngoingPauseEvents?: boolean | null, hasScheduledPauseEvents?: boolean | null, stakeholderType?: string | null, isTrust?: boolean | null } | null> | null } | null };\n\nexport type OffersVestingEventsEsopQueryVariables = Exact<{\n  offerIds: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n}>;\n\n\nexport type OffersVestingEventsEsopQuery = { __typename?: 'Query', optionPoolOffersVestingEvents?: Array<{ __typename?: 'EsopVestingEventType', id: string, offerId?: string | null, order: number, vestingValue: number, eventType?: string | null, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null };\n\nexport type OffersVestingEventsEsop2QueryVariables = Exact<{\n  offerIds: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n}>;\n\n\nexport type OffersVestingEventsEsop2Query = { __typename?: 'Query', offersVestingEvents?: Array<{ __typename?: 'EsopVestingEventType', id: string, offerId?: string | null, order: number, vestingValue: number, eventType?: string | null, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null };\n\nexport type GetPlanToEditEssQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  planId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetPlanToEditEssQuery = { __typename?: 'Query', plan?: Array<{ __typename?: 'Ess', id: string, name?: string | null, vestingValue?: number | null, requireWitness: boolean, totalVested?: number | null, totalLapsed?: number | null, totalGranted?: number | null, totalOffered?: number | null, group?: Array<{ __typename?: 'EssOfferGroup', id: string, country?: string | null, isEditable?: boolean | null, totalOffered?: number | null, totalGranted?: number | null, totalVested?: number | null, totalLapsed?: number | null, totalExercised?: number | null, allowNomineeTrust: boolean, requireBoardApproval: boolean, loanFunded: boolean, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } | null> | null } | null> | null, sharetypes?: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string } | null> | null };\n\nexport type EditEssMutationVariables = Exact<{\n  plan: Scalars['EssCakeType']['input'];\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  vestingValue?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type EditEssMutation = { __typename?: 'Mutation', editEss?: boolean | null };\n\nexport type EditGroupAndEssMutationVariables = Exact<{\n  plan: Scalars['EssCakeType']['input'];\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  vestingValue?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  group: Scalars['EssOfferGroupCakeType']['input'];\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  enforceDisclosurePeriod?: InputMaybe<Scalars['Boolean']['input']>;\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n  loanFunded?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type EditGroupAndEssMutation = { __typename?: 'Mutation', editEss?: boolean | null, editGroupEss?: boolean | null };\n\nexport type DeleteEssMutationVariables = Exact<{\n  plan: Scalars['EssCakeType']['input'];\n}>;\n\n\nexport type DeleteEssMutation = { __typename?: 'Mutation', deleteEss?: boolean | null };\n\nexport type GetPlansEssQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetPlansEssQuery = { __typename?: 'Query', plans?: Array<{ __typename?: 'Ess', id: string, name?: string | null, vestingValue?: number | null, percentageOfOrganisationShares?: number | null, totalVested?: number | null, totalLapsed?: number | null, totalOffered?: number | null, group?: Array<{ __typename?: 'EssOfferGroup', country?: string | null } | null> | null } | null> | null, organisation?: { __typename?: 'Organisation', fullyDilutedShares?: number | null } | null };\n\nexport type GetPlanNamesEssQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetPlanNamesEssQuery = { __typename?: 'Query', esss?: Array<{ __typename?: 'Ess', id: string, name?: string | null } | null> | null };\n\nexport type GetSharePlanQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  essId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetSharePlanQuery = { __typename?: 'Query', plan?: Array<{ __typename?: 'Ess', id: string, name?: string | null, vestingValue?: number | null, commentCount?: number | null, requireWitness: boolean, totalVested?: number | null, totalLapsed?: number | null, totalGranted?: number | null, totalOffered?: number | null, organisation: { __typename?: 'Organisation', id: string, created: string, fullyDilutedShares?: number | null, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null }, documents?: Array<{ __typename?: 'Document', id: string, created: string, name?: string | null, file?: string | null, extension?: string | null } | null> | null, group?: Array<{ __typename?: 'EssOfferGroup', id: string, country?: string | null, offerCount?: number | null, offerAcceptedCount?: number | null, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null, defaultPlanRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null, defaultOfferLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null, planRulesTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices }>, offerLetterTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices }> } | null> | null } | null> | null };\n\nexport type GetPlanGroupEssQueryVariables = Exact<{\n  groupId: Scalars['EssOfferGroupCakeType']['input'];\n}>;\n\n\nexport type GetPlanGroupEssQuery = { __typename?: 'Query', group?: { __typename?: 'EssOfferGroup', id: string, country?: string | null, offerCount?: number | null, offerAcceptedCount?: number | null, loanFunded: boolean, totalGranted?: number | null, totalVested?: number | null, totalLapsed?: number | null, isEditable?: boolean | null, offerLetterTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, modified: string }>, planRulesTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null, modified: string }>, plan: { __typename?: 'Ess', id: string, name?: string | null }, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } | null };\n\nexport type GetPlanOffersToCompleteEssQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n}>;\n\n\nexport type GetPlanOffersToCompleteEssQuery = { __typename?: 'Query', offers?: Array<{ __typename?: 'EssOffer', id: string, vestStartDate?: string | null, country?: string | null, status?: string | null, sharePrice?: number | null, sharePriceReal?: number | null, shareholderDisplayName?: string | null, shareholder?: { __typename?: 'Shareholder', id: string, secondaryName?: string | null, avatar?: string | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null } | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, jointIndex: number, companyData?: { __typename?: 'CompanyDataType', signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null } | null> | null } | null } | null> | null } | null, offerLetterTemplate?: { __typename?: 'Document', id: string } | null, group: { __typename?: 'EssOfferGroup', id: string, country?: string | null, offerLetterTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, status?: string | null, contractType?: string | null, modified: string }>, planRulesTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, modified: string, extension?: string | null }>, defaultPlanRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null, defaultOfferLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null } } | null> | null };\n\nexport type GetPlanOffersEssQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  filterId: Scalars['UUID']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  filters?: InputMaybe<Array<ListFilterType> | ListFilterType>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']> | Scalars['CleanString']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type GetPlanOffersEssQuery = { __typename?: 'Query', offers?: { __typename?: 'PaginatedEssOffer', count: number, currentPage: number, notSignedUpCount?: number | null, shareholderCount?: number | null, plan?: { __typename?: 'Ess', id: string, vestingValue?: number | null, totalOffered?: number | null, totalLapsed?: number | null, organisation: { __typename?: 'Organisation', fullyDilutedShares?: number | null } } | null, pageData?: Array<{ __typename?: 'ListContextVestingOfferType', id?: string | null, modified?: string | null, groupId?: string | null, planId?: string | null, offerLetterId?: string | null, dateGranted?: string | null, vestStartDate?: string | null, emailsOn?: boolean | null, requireWitness?: boolean | null, shareholderId?: string | null, shareholderDisplayName?: string | null, shareholderSecondaryName?: string | null, shareholderAvatar?: string | null, shareholderHasLoggedIn?: boolean | null, shareholderConsideredInvited?: boolean | null, shEmail?: string | null, status?: string | null, softStatus?: string | null, country?: string | null, vestingValue?: number | null, availableToLapse?: number | null, availableToExercise?: number | null, availableToVest?: number | null, vested?: number | null, granted?: number | null, lapsed?: number | null, exercised?: number | null, hasOngoingPauseEvents?: boolean | null, hasScheduledPauseEvents?: boolean | null, stakeholderType?: string | null, isTrust?: boolean | null } | null> | null } | null };\n\nexport type OffersVestingEventsEssQueryVariables = Exact<{\n  offerIds: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n}>;\n\n\nexport type OffersVestingEventsEssQuery = { __typename?: 'Query', offersVestingEvents?: Array<{ __typename?: 'EssVestingEventType', id: string, offerId?: string | null, order: number, vestingValue: number, eventType?: string | null, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null };\n\nexport type EssOfferQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type EssOfferQuery = { __typename?: 'Query', offer?: { __typename?: 'EssOffer', id: string, created: string, modified: string, sharePrice?: number | null, sharePriceReal?: number | null, loanFunded: boolean, group: { __typename?: 'EssOfferGroup', sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null, plan: { __typename?: 'Ess', id: string, name?: string | null, vestingValue?: number | null, totalOffered?: number | null, totalLapsed?: number | null, documents?: Array<{ __typename?: 'Document', id: string, name?: string | null, extension?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null> | null, organisation: { __typename?: 'Organisation', id: string, name: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, totalShares?: number | null, created: string, totalSharesUnexercised?: number | null, fullyDilutedShares?: number | null, valuationVisibleToOptionholders?: boolean | null, logoImage?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null }, group?: Array<{ __typename?: 'EssOfferGroup', id: string, country?: string | null, sharetype?: { __typename?: 'Sharetype', symbol: string, voting: boolean, dividend: boolean } | null, offerLetterTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, modified: string }>, planRulesTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null, modified: string }> } | null> | null } }, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, inviteLink?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, inviteLink?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null } | null } } | null };\n\nexport type GetDataToVestOfferFoundervestingQueryVariables = Exact<{\n  offer: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetDataToVestOfferFoundervestingQuery = { __typename?: 'Query', investorHoldings?: { __typename?: 'FounderVestingOfferOutputType', availableToPeriodicVest?: number | null, vested?: number | null, id: string, vestingEvents?: Array<{ __typename?: 'FounderVestingVestingEventOutputType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'FounderVestingTransactionOutputType', id: string, vestingValue?: number | null, type: FoundervestingFounderVestingTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, reminderDate?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null } | null };\n\nexport type GetDataToLapseOfferFoundervestingQueryVariables = Exact<{\n  offer: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetDataToLapseOfferFoundervestingQuery = { __typename?: 'Query', lapseData?: { __typename?: 'FounderVestingOfferOutputType', id: string, vestStartDate?: string | null, softStatus?: string | null, granted?: number | null, vestablePeriodic?: number | null, lapsed?: number | null, lapsedPeriodic?: number | null, exercised?: number | null, availableToPeriodicVest?: number | null, availableToVestMilestone?: number | null, availableToLapse?: number | null, pauseEvents?: Array<{ __typename?: 'FounderVestingOfferPauseEventOutputType', status?: string | null } | null> | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null }, calendar?: { __typename?: 'OfferCalendarOutputType', entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, entryType?: string | null }> | null } | null, vestingEvents?: Array<{ __typename?: 'FounderVestingVestingEventOutputType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'FounderVestingTransactionOutputType', id: string, transactionDate: string, vestingValue?: number | null, type: FoundervestingFounderVestingTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null } | null } | null> | null } | null };\n\nexport type GetDataToPauseFoundervestingQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetDataToPauseFoundervestingQuery = { __typename?: 'Query', offer?: { __typename?: 'FounderVestingOfferOutputType', id: string, softStatus?: string | null, pauseEvents?: Array<{ __typename?: 'FounderVestingOfferPauseEventOutputType', id: string, pauseDate: string, resumeDate: string, status?: string | null } | null> | null } | null };\n\nexport type DeleteOffersFoundervestingMutationVariables = Exact<{\n  offers: Array<InputMaybe<Scalars['FounderVestingOfferCakeType']['input']>> | InputMaybe<Scalars['FounderVestingOfferCakeType']['input']>;\n}>;\n\n\nexport type DeleteOffersFoundervestingMutation = { __typename?: 'Mutation', deleteOffersFounderVesting?: number | null };\n\nexport type LapseOfferFoundervestingMutationVariables = Exact<{\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n  lapseDate: Scalars['Date']['input'];\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n}>;\n\n\nexport type LapseOfferFoundervestingMutation = { __typename?: 'Mutation', lapseOfferFounderVesting?: boolean | null };\n\nexport type LapseOfferMilestoneFoundervestingMutationVariables = Exact<{\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n  lapseDate: Scalars['Date']['input'];\n  milestoneEvents: Array<LapseMilestoneEntryInputType> | LapseMilestoneEntryInputType;\n}>;\n\n\nexport type LapseOfferMilestoneFoundervestingMutation = { __typename?: 'Mutation', lapseMilestoneFounderVesting?: boolean | null };\n\nexport type FullyLapseOfferFoundervestingMutationVariables = Exact<{\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n  acceleratedValue: Scalars['PositiveIntegerOrZero']['input'];\n}>;\n\n\nexport type FullyLapseOfferFoundervestingMutation = { __typename?: 'Mutation', fullyLapseOfferFounderVesting?: boolean | null };\n\nexport type VestCliffOrPeriodicFoundervestingMutationVariables = Exact<{\n  offer: Scalars['FounderVestingOfferCakeType']['input'];\n  transactionDate: Scalars['Date']['input'];\n  vestingValue: Scalars['PositiveIntegerOrZero']['input'];\n}>;\n\n\nexport type VestCliffOrPeriodicFoundervestingMutation = { __typename?: 'Mutation', vestCliffOrPeriodicFounderVesting?: boolean | null };\n\nexport type VestOfferMilestonesFoundervestingMutationVariables = Exact<{\n  milestoneList: Array<InputMaybe<MilestoneVestType>> | InputMaybe<MilestoneVestType>;\n}>;\n\n\nexport type VestOfferMilestonesFoundervestingMutation = { __typename?: 'Mutation', vestOfferMilestonesFounderVesting?: boolean | null };\n\nexport type CreateOfferPauseEventFoundervestingMutationVariables = Exact<{\n  founderVestingOffer: Scalars['FounderVestingOfferCakeType']['input'];\n  pauseDate: Scalars['Date']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type CreateOfferPauseEventFoundervestingMutation = { __typename?: 'Mutation', createOfferPauseEventFounderVesting?: boolean | null };\n\nexport type EditOfferPauseEventFoundervestingMutationVariables = Exact<{\n  pauseEvent: Scalars['FounderVestingOfferPauseEventCakeType']['input'];\n  pauseDate: Scalars['Date']['input'];\n  resumeDate?: InputMaybe<Scalars['Date']['input']>;\n  forceSave?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type EditOfferPauseEventFoundervestingMutation = { __typename?: 'Mutation', editOfferPauseEventFounderVesting?: boolean | null };\n\nexport type DeleteOfferPauseEventFoundervestingMutationVariables = Exact<{\n  pauseEvent: Scalars['FounderVestingOfferPauseEventCakeType']['input'];\n  force?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type DeleteOfferPauseEventFoundervestingMutation = { __typename?: 'Mutation', deleteOfferPauseEventFounderVesting?: boolean | null };\n\nexport type IssueSharesFounderVestingMutationVariables = Exact<{\n  issueSharesInput: IssueSharesInput;\n  offerData: OfferInputType;\n}>;\n\n\nexport type IssueSharesFounderVestingMutation = { __typename?: 'Mutation', issueSharesFounderVesting?: boolean | null };\n\nexport type Update83bFormDownloadStatusMutationVariables = Exact<{\n  offerId: Scalars['FounderVestingOfferCakeType']['input'];\n}>;\n\n\nexport type Update83bFormDownloadStatusMutation = { __typename?: 'Mutation', update83bFormDownloadStatus?: boolean | null };\n\nexport type OnOffAutoVestEmailsFounderVestingMutationVariables = Exact<{\n  offers: Array<Scalars['FounderVestingOfferCakeType']['input']> | Scalars['FounderVestingOfferCakeType']['input'];\n  emailsOn: Scalars['Boolean']['input'];\n}>;\n\n\nexport type OnOffAutoVestEmailsFounderVestingMutation = { __typename?: 'Mutation', onOffAutoVestEmailsFounderVesting?: boolean | null };\n\nexport type GetMessageAnalyticsQueryVariables = Exact<{\n  replyThread: Scalars['CakeReplyThreadCakeType']['input'];\n  page?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n}>;\n\n\nexport type GetMessageAnalyticsQuery = { __typename?: 'Query', messageAnalytics?: { __typename?: 'PaginatedMessageAnalyticsType', currentPage: number, count: number, messageId?: string | null, uniqueOpenCount?: number | null, allowReactions?: boolean | null, pageData?: Array<{ __typename?: 'MessageAnalyticsEntryType', displayName?: string | null, openCount?: number | null, avatar?: string | null, hasLoggedIn?: boolean | null, reaction?: string | null } | null> | null } | null };\n\nexport type SendMessageMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareholderIdList: Array<InputMaybe<Scalars['ShareholderCakeType']['input']>> | InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  groupIdList: Array<InputMaybe<Scalars['CakeGroupCakeType']['input']>> | InputMaybe<Scalars['CakeGroupCakeType']['input']>;\n  fromShareholder?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  body: Scalars['CleanString']['input'];\n  subject: Scalars['CleanString']['input'];\n  message?: InputMaybe<Scalars['CakeMessageCakeType']['input']>;\n  allowReactions?: InputMaybe<Scalars['Boolean']['input']>;\n  allowReplies?: InputMaybe<Scalars['Boolean']['input']>;\n  attachments?: InputMaybe<Array<InputMaybe<Scalars['DocumentCakeType']['input']>> | InputMaybe<Scalars['DocumentCakeType']['input']>>;\n  rootMessage?: InputMaybe<Scalars['CakeMessageCakeType']['input']>;\n  replyThread?: InputMaybe<Scalars['CakeReplyThreadCakeType']['input']>;\n}>;\n\n\nexport type SendMessageMutation = { __typename?: 'Mutation', sendMessage?: { __typename?: 'SendMessageOutputType', messageId?: string | null, replyThreadId?: string | null } | null };\n\nexport type SaveMessageMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareholderIdList: Array<InputMaybe<Scalars['ShareholderCakeType']['input']>> | InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  groupIdList: Array<InputMaybe<Scalars['CakeGroupCakeType']['input']>> | InputMaybe<Scalars['CakeGroupCakeType']['input']>;\n  fromShareholder?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  body: Scalars['String']['input'];\n  subject: Scalars['String']['input'];\n  message?: InputMaybe<Scalars['CakeMessageCakeType']['input']>;\n  allowReactions?: InputMaybe<Scalars['Boolean']['input']>;\n  allowReplies?: InputMaybe<Scalars['Boolean']['input']>;\n  attachments?: InputMaybe<Array<InputMaybe<Scalars['DocumentCakeType']['input']>> | InputMaybe<Scalars['DocumentCakeType']['input']>>;\n  rootMessage?: InputMaybe<Scalars['CakeMessageCakeType']['input']>;\n  replyThread?: InputMaybe<Scalars['CakeReplyThreadCakeType']['input']>;\n}>;\n\n\nexport type SaveMessageMutation = { __typename?: 'Mutation', saveMessage?: string | null };\n\nexport type DeleteMessageMutationVariables = Exact<{\n  message: Scalars['CakeMessageCakeType']['input'];\n}>;\n\n\nexport type DeleteMessageMutation = { __typename?: 'Mutation', deleteMessage?: boolean | null };\n\nexport type UpdateMessageAnalyticsMutationVariables = Exact<{\n  messageId: Scalars['CakeMessageCakeType']['input'];\n}>;\n\n\nexport type UpdateMessageAnalyticsMutation = { __typename?: 'Mutation', updateMessageAnalytics?: boolean | null };\n\nexport type ToggleMessageAllowRepliesMutationVariables = Exact<{\n  message: Scalars['CakeMessageCakeType']['input'];\n  allowReplies: Scalars['Boolean']['input'];\n}>;\n\n\nexport type ToggleMessageAllowRepliesMutation = { __typename?: 'Mutation', toggleMessageAllowReplies?: boolean | null };\n\nexport type ToggleOrganisationAllowRepliesMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  allowReplies: Scalars['Boolean']['input'];\n}>;\n\n\nexport type ToggleOrganisationAllowRepliesMutation = { __typename?: 'Mutation', toggleOrganisationAllowReplies?: boolean | null };\n\nexport type OrganisationInboxQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n}>;\n\n\nexport type OrganisationInboxQuery = { __typename?: 'Query', organisationAllowMessageReplies: boolean, organisationInbox: { __typename?: 'PaginatedInboxListType', count: number, currentPage: number, pageData: Array<{ __typename?: 'InboxItemType', id: string, organisationId: string, organisationName: string, avatarImage?: string | null, avatarName?: string | null, threadLength: number, created: string, subject: string, nRecipients: number, hasAttachments: boolean, hasUnreadMessages: boolean, lastMessageStatus: MessageStatus }> } };\n\nexport type OrganisationAllowMessageRepliesQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type OrganisationAllowMessageRepliesQuery = { __typename?: 'Query', organisationAllowMessageReplies: boolean };\n\nexport type OrganisationMessageThreadQueryVariables = Exact<{\n  replyThreadId: Scalars['CakeReplyThreadCakeType']['input'];\n  page?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  isEdit?: InputMaybe<Scalars['Boolean']['input']>;\n  inReply?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type OrganisationMessageThreadQuery = { __typename?: 'Query', organisationMessageThread?: { __typename?: 'CakeReplyThreadType', id: string, participants?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null }>, replyingShareholders?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null } | null> | null, rootMessage: { __typename?: 'CakeMessageType', allowReplies?: boolean | null, allowReactions: boolean, id: string, created: string, subject: string, body: string, bodyParsed?: string | null, isSeen?: boolean | null, isDraft?: boolean | null, replyThread?: { __typename?: 'CakeReplyThreadType', id: string } | null, draft?: { __typename?: 'DraftMessagePayloadType', groups?: Array<{ __typename?: 'DraftMessageTargetType', name?: string | null, id?: string | null } | null> | null, shareholders?: Array<{ __typename?: 'DraftMessageTargetType', name?: string | null, id?: string | null } | null> | null } | null, reactionAggregates?: Array<{ __typename?: 'CakeMessageReactionCountType', reaction?: string | null, count?: number | null, stakeholders?: Array<string | null> | null } | null> | null, attachments: Array<{ __typename?: 'Document', id: string, name?: string | null, modified: string, extension?: string | null }>, user?: { __typename?: 'UserType', firstName: string, lastName: string, picture: string } | null, organisation: { __typename?: 'Organisation', id: string, name: string, logo: string } }, messages?: { __typename?: 'PaginatedMessageType', currentPage: number, count: number, pageData?: Array<{ __typename?: 'CakeMessageType', created: string, id: string, subject: string, body: string, isDraft?: boolean | null, isSeen?: boolean | null, isCompanyMessage?: boolean | null, organisation: { __typename?: 'Organisation', id: string, name: string, logo?: string | null }, attachments: Array<{ __typename?: 'Document', id: string, name?: string | null, modified: string, extension?: string | null }>, user?: { __typename?: 'UserType', firstName: string, lastName: string, picture: string } | null } | null> | null } | null } | null };\n\nexport type GetShareholdersForAutocompleteQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['Int']['input'];\n  itemsPerPage: Scalars['Int']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n  shareholderIdsToExclude?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>>;\n}>;\n\n\nexport type GetShareholdersForAutocompleteQuery = { __typename?: 'Query', paginatedShareholders?: { __typename?: 'PaginatedShareholderType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null, employeeData?: { __typename?: 'EmployeeDataType', role: SeEmployeeDataRoleChoices, level: SeEmployeeDataLevelChoices } | null } | null> | null } | null };\n\nexport type CreateEquityModelMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  modelData: EquityModelDataInputType;\n  conversionMethodology?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type CreateEquityModelMutation = { __typename?: 'Mutation', createEquityModel?: boolean | null };\n\nexport type EditEquityModelMutationVariables = Exact<{\n  equityModel: Scalars['EquityModelCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  modelData: EquityModelDataInputType;\n  conversionMethodology?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type EditEquityModelMutation = { __typename?: 'Mutation', editEquityModel?: boolean | null };\n\nexport type DeleteEquityModelMutationVariables = Exact<{\n  equityModel: Scalars['EquityModelCakeType']['input'];\n}>;\n\n\nexport type DeleteEquityModelMutation = { __typename?: 'Mutation', deleteEquityModel?: boolean | null };\n\nexport type EquityModelsQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type EquityModelsQuery = { __typename?: 'Query', equityModels?: Array<{ __typename?: 'EquityModelOutputType', id: string, name: string, modified: string, conversionMethodology?: string | null, modelData: { __typename?: 'EquityModelDataOutputType', rounds?: Array<{ __typename?: 'EquityRoundOutputType', equityRound: string, roundType?: EquityRoundTypeOutputField | null, proposedValuation: number, investmentValue?: number | null, topUpOptionPoolPrct: number, convertNotes?: EquityRoundNoteConversionOutputField | null, roundMethodology?: string | null, topUpSequence?: string | null, investors?: Array<{ __typename?: 'EquityModelRoundInvestorOutputType', name: string, investment: number } | null> | null } | null> | null, notes?: Array<{ __typename?: 'NoteConversionSimulationOutputType', investorName: string, principalIncludingInterest: number, valuationCap: number, discountRate: number, convertOnRound: number } | null> | null } } | null> | null };\n\nexport type NotesOffersQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  noteType?: InputMaybe<NoteType>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']> | Scalars['CleanString']['input']>;\n  filters?: InputMaybe<Array<ListFilterType> | ListFilterType>;\n  search?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type NotesOffersQuery = { __typename?: 'Query', notesOffers?: { __typename?: 'PaginatedNoteOffer', count: number, shareholderCount: number, notSignedUpCount: number, currentPage: number, pageData: Array<{ __typename?: 'ListContextNoteOfferType', id: string, roundName?: string | null, noteType: NoteType, contractId?: string | null, shareholderId: string, shareholderDisplayName: string, shareholderSecondaryName?: string | null, shareholderAvatar?: string | null, shareholderHasLoggedIn: boolean, shareholderConsideredInvited: boolean, shEmail?: string | null, issueDate?: string | null, principal: number, discountRate?: number | null, valuationCap?: number | null, resolutionDate?: string | null, maturityDate?: string | null, interestRate?: number | null, softStatus: string, stakeholderType: string, isTrust: boolean }> } | null };\n\nexport type NotesOfferQueryVariables = Exact<{\n  notesOffer: Scalars['NotesRoundOfferCakeType']['input'];\n}>;\n\n\nexport type NotesOfferQuery = { __typename?: 'Query', notesOffer?: { __typename?: 'NotesRoundOfferType', id: string, modified: string, noteType?: NoteType | null, status: NotesroundsNotesRoundOfferStatusChoices, principal?: number | null, discountRate?: number | null, valuationCap?: number | null, maturityDate?: string | null, interestRate?: number | null, requireWitness: boolean, note?: { __typename?: 'Note', resolution?: NotesNoteResolutionChoices | null, resolutionDate?: string | null, issueDate: string } | null, contractTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractLink?: string | null } | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null }, contract?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, extension?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null, extra?: string | null } | null> | null } | null, notesRound: { __typename?: 'NotesRoundType', id: string, name: string }, payment?:\n      | { __typename?: 'AuPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, bsb?: string | null, reference?: string | null, isTrustAccount?: boolean | null }\n      | { __typename?: 'FallbackPaymentDetailsType', details?: string | null }\n      | { __typename?: 'SgPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, swiftCode?: string | null, bankCode?: string | null, branchCode?: string | null }\n     | null } | null };\n\nexport type GetNoteQueryVariables = Exact<{\n  noteId: Scalars['NoteCakeType']['input'];\n}>;\n\n\nexport type GetNoteQuery = { __typename?: 'Query', note?: { __typename?: 'Note', id: string, resolution?: NotesNoteResolutionChoices | null, principal?: number | null, discountRate?: number | null, maturityDate?: string | null, interestRate?: number | null, issueDate: string, valuationCap?: number | null, noteType: NotesNoteTypeChoices, shareholder: { __typename?: 'Shareholder', displayName?: string | null } } | null };\n\nexport type RepayNoteMutationVariables = Exact<{\n  noteId: Scalars['UUID']['input'];\n}>;\n\n\nexport type RepayNoteMutation = { __typename?: 'Mutation', repayNote?: { __typename?: 'RepayNote', ok?: boolean | null } | null };\n\nexport type GetStakeholdersToAddNoteQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['Int']['input'];\n  itemsPerPage: Scalars['Int']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type GetStakeholdersToAddNoteQuery = { __typename?: 'Query', paginatedShareholders?: { __typename?: 'PaginatedShareholderType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null, employeeData?: { __typename?: 'EmployeeDataType', role: SeEmployeeDataRoleChoices, level: SeEmployeeDataLevelChoices } | null } | null> | null } | null };\n\nexport type GetNotesRoundToAddNoteQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetNotesRoundToAddNoteQuery = { __typename?: 'Query', notesRounds?: Array<{ __typename?: 'NotesRoundType', id: string, name: string } | null> | null };\n\nexport type GetNotesRoundsNamesQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type GetNotesRoundsNamesQuery = { __typename?: 'Query', notesRoundsNames?: { __typename?: 'PaginatedStringList', pageData: Array<string> } | null };\n\nexport type GetNotesRoundsQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetNotesRoundsQuery = { __typename?: 'Query', notesRounds?: Array<{ __typename?: 'NotesRoundType', id: string, name: string, noteType: NotesroundsNotesRoundNoteTypeChoices, contractTemplate?: { __typename?: 'Document', id: string } | null } | null> | null };\n\nexport type CreateNotesOfferMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  noteType: Scalars['String']['input'];\n  principal: Scalars['CakeDecimal']['input'];\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  round?: InputMaybe<Scalars['String']['input']>;\n  contractTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  contractTemplateFromMaster?: InputMaybe<Scalars['Boolean']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  existingShareholder?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  newShareholder?: InputMaybe<InvestorAndEmployeeDataInput>;\n}>;\n\n\nexport type CreateNotesOfferMutation = { __typename?: 'Mutation', createNotesOffer?: { __typename?: 'NotesRoundOfferType', id: string } | null };\n\nexport type EditNotesOfferMutationVariables = Exact<{\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  noteType: Scalars['String']['input'];\n  principal: Scalars['CakeDecimal']['input'];\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  round?: InputMaybe<Scalars['String']['input']>;\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n}>;\n\n\nexport type EditNotesOfferMutation = { __typename?: 'Mutation', editNotesOffer?: boolean | null };\n\nexport type CreateTemplateNoteMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  templateType: Scalars['String']['input'];\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  baseTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n}>;\n\n\nexport type CreateTemplateNoteMutation = { __typename?: 'Mutation', createTemplateNote?: boolean | null };\n\nexport type SetNotesRoundTemplateMutationVariables = Exact<{\n  round: Scalars['NotesRoundCakeType']['input'];\n  contractTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n}>;\n\n\nexport type SetNotesRoundTemplateMutation = { __typename?: 'Mutation', setNotesRoundTemplate?: boolean | null };\n\nexport type SetNotesOfferTemplateMutationVariables = Exact<{\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  contractTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n}>;\n\n\nexport type SetNotesOfferTemplateMutation = { __typename?: 'Mutation', setNotesOfferTemplate?: boolean | null };\n\nexport type CreateNotesOfferTemplateMutationVariables = Exact<{\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n}>;\n\n\nexport type CreateNotesOfferTemplateMutation = { __typename?: 'Mutation', createNotesOfferTemplate?: boolean | null };\n\nexport type GetMasterTemplateViewLinkQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  contractType: Scalars['CleanString']['input'];\n}>;\n\n\nexport type GetMasterTemplateViewLinkQuery = { __typename?: 'Query', templateViewLink?: string | null };\n\nexport type GetNoteOfferToConvertQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  notesOffer: Scalars['NotesRoundOfferCakeType']['input'];\n}>;\n\n\nexport type GetNoteOfferToConvertQuery = { __typename?: 'Query', notesOffer?: { __typename?: 'NotesRoundOfferType', id: string, noteType?: NoteType | null, status: NotesroundsNotesRoundOfferStatusChoices, principal?: number | null, discountRate?: number | null, valuationCap?: number | null, maturityDate?: string | null, interestRate?: number | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null }, notesRound: { __typename?: 'NotesRoundType', id: string, name: string }, note?: { __typename?: 'Note', issueDate: string } | null } | null, sharetypes?: Array<{ __typename?: 'Sharetype', id: string, name: string } | null> | null, organisation?: { __typename?: 'Organisation', fullyDilutedShares?: number | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null } | null };\n\nexport type GetNoteOfferToInviteQueryVariables = Exact<{\n  notesOffer: Scalars['NotesRoundOfferCakeType']['input'];\n}>;\n\n\nexport type GetNoteOfferToInviteQuery = { __typename?: 'Query', notesOffer?: { __typename?: 'NotesRoundOfferType', id: string, notesRound: { __typename?: 'NotesRoundType', id: string, name: string, payment?:\n        | { __typename?: 'AuPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, bsb?: string | null, reference?: string | null, isTrustAccount?: boolean | null }\n        | { __typename?: 'FallbackPaymentDetailsType', details?: string | null }\n        | { __typename?: 'SgPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, swiftCode?: string | null, bankCode?: string | null, branchCode?: string | null }\n       | null } } | null };\n\nexport type GetNoteOfferToEditQueryVariables = Exact<{\n  notesOffer: Scalars['NotesRoundOfferCakeType']['input'];\n}>;\n\n\nexport type GetNoteOfferToEditQuery = { __typename?: 'Query', notesOffer?: { __typename?: 'NotesRoundOfferType', id: string, noteType?: NoteType | null, status: NotesroundsNotesRoundOfferStatusChoices, principal?: number | null, discountRate?: number | null, valuationCap?: number | null, maturityDate?: string | null, interestRate?: number | null, shareType?: { __typename?: 'Sharetype', id: string } | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null }, notesRound: { __typename?: 'NotesRoundType', id: string, name: string } } | null };\n\nexport type CreateNotesRoundMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  noteType: Scalars['String']['input'];\n  roundInvestmentGoal: Scalars['CakeDecimal']['input'];\n  capitalRaisingEventAmount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  endDate?: InputMaybe<Scalars['Date']['input']>;\n  payment?: InputMaybe<Scalars['JSONString']['input']>;\n}>;\n\n\nexport type CreateNotesRoundMutation = { __typename?: 'Mutation', createNotesRound?: { __typename?: 'CreateNotesRound', notesRound?: { __typename?: 'NotesRoundType', id: string, name: string } | null } | null };\n\nexport type EditNotesRoundMutationVariables = Exact<{\n  round: Scalars['NotesRoundCakeType']['input'];\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  endDate?: InputMaybe<Scalars['Date']['input']>;\n  roundInvestmentGoal?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  capitalRaisingEventAmount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n}>;\n\n\nexport type EditNotesRoundMutation = { __typename?: 'Mutation', editNotesRound?: { __typename?: 'EditNotesRound', ok?: boolean | null } | null };\n\nexport type UpdateNotesRoundBankDetailsAuMutationVariables = Exact<{\n  round: Scalars['NotesRoundCakeType']['input'];\n  accountName?: InputMaybe<Scalars['String']['input']>;\n  paymentAccount?: InputMaybe<Scalars['String']['input']>;\n  paymentBsb?: InputMaybe<Scalars['String']['input']>;\n  paymentReference?: InputMaybe<Scalars['String']['input']>;\n  isTrustAccount?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type UpdateNotesRoundBankDetailsAuMutation = { __typename?: 'Mutation', updateNotesRoundBankDetailsAu?: { __typename?: 'UpdateNotesRoundBankDetailsAu', ok?: boolean | null } | null };\n\nexport type UpdateNotesRoundBankDetailsSgMutationVariables = Exact<{\n  round: Scalars['NotesRoundCakeType']['input'];\n  accountName?: InputMaybe<Scalars['String']['input']>;\n  accountNumber?: InputMaybe<Scalars['String']['input']>;\n  swiftCode?: InputMaybe<Scalars['String']['input']>;\n  bankCode?: InputMaybe<Scalars['String']['input']>;\n  branchCode?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type UpdateNotesRoundBankDetailsSgMutation = { __typename?: 'Mutation', updateNotesRoundBankDetailsSg?: { __typename?: 'UpdateNotesRoundBankDetailsSg', ok?: boolean | null } | null };\n\nexport type UpdateNotesRoundBankDetailsFallbackMutationVariables = Exact<{\n  round: Scalars['NotesRoundCakeType']['input'];\n  details?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type UpdateNotesRoundBankDetailsFallbackMutation = { __typename?: 'Mutation', updateNotesRoundBankDetailsFallback?: { __typename?: 'UpdateNotesRoundBankDetailsFallback', ok?: boolean | null } | null };\n\nexport type DeleteNotesRoundMutationVariables = Exact<{\n  round: Scalars['NotesRoundCakeType']['input'];\n}>;\n\n\nexport type DeleteNotesRoundMutation = { __typename?: 'Mutation', deleteNotesRound?: { __typename?: 'DeleteNotesRound', ok?: boolean | null } | null };\n\nexport type GetNotesRoundQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  roundId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetNotesRoundQuery = { __typename?: 'Query', notesRounds?: Array<{ __typename?: 'NotesRoundType', id: string, name: string, roundInvestmentGoal?: number | null, created: string, noteType: NotesroundsNotesRoundNoteTypeChoices, amountRaised?: number | null, amountPaid?: number | null, minInvestmentAmount?: number | null, maxInvestmentAmount?: number | null, endDate?: string | null, capitalRaisingEventAmount?: number | null, valuationCap?: number | null, interestRate?: number | null, discountRate?: number | null, maturityDate?: string | null, payment?:\n      | { __typename?: 'AuPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, bsb?: string | null, reference?: string | null, isTrustAccount?: boolean | null }\n      | { __typename?: 'FallbackPaymentDetailsType', details?: string | null }\n      | { __typename?: 'SgPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, swiftCode?: string | null, bankCode?: string | null, branchCode?: string | null }\n     | null, contractTemplate?: { __typename?: 'Document', id: string, name?: string | null, status?: string | null, contractType?: string | null } | null, shareType?: { __typename?: 'Sharetype', id: string, name: string } | null, documents?: Array<{ __typename?: 'Document', id: string, created: string, name?: string | null, file?: string | null, extension?: string | null } | null> | null } | null> | null, officeholders?: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, avatar?: string | null, signer?: SeOfficeholderSignerChoices | null, roles: Array<{ __typename?: 'OfficeholderRoleType', role: SeOfficeholderRoleRoleChoices, name?: string | null }> } | null> | null };\n\nexport type NotesRoundOffersQueryVariables = Exact<{\n  round: Scalars['NotesRoundCakeType']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  offer?: InputMaybe<Scalars['UUID']['input']>;\n}>;\n\n\nexport type NotesRoundOffersQuery = { __typename?: 'Query', notesRoundOffers?: Array<{ __typename?: 'NotesRoundOfferType', id: string, modified: string, status: NotesroundsNotesRoundOfferStatusChoices, principal?: number | null, owing?: number | null, requireWitness: boolean, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, secondaryName?: string | null, avatar?: string | null, inviteLink?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, jointIndex: number, companyData?: { __typename?: 'CompanyDataType', signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null } | null> | null } | null } | null> | null }, contract?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null, extra?: string | null } | null> | null } | null, notesRound: { __typename?: 'NotesRoundType', id: string, noteType: NotesroundsNotesRoundNoteTypeChoices } } | null> | null };\n\nexport type CreateNotesRoundTemplateMutationVariables = Exact<{\n  round: Scalars['NotesRoundCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  baseTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n}>;\n\n\nexport type CreateNotesRoundTemplateMutation = { __typename?: 'Mutation', createNotesRoundTemplate?: { __typename?: 'CreateNotesRoundTemplate', ok?: boolean | null } | null };\n\nexport type DeleteNotesRoundTemplateMutationVariables = Exact<{\n  round: Scalars['NotesRoundCakeType']['input'];\n}>;\n\n\nexport type DeleteNotesRoundTemplateMutation = { __typename?: 'Mutation', deleteNotesRoundTemplate?: { __typename?: 'DeleteNotesRoundTemplate', ok?: boolean | null } | null };\n\nexport type AddNotesRoundOfferMutationVariables = Exact<{\n  round: Scalars['NotesRoundCakeType']['input'];\n  shareholder: Scalars['ShareholderCakeType']['input'];\n  principal: Scalars['CakeDecimal']['input'];\n}>;\n\n\nexport type AddNotesRoundOfferMutation = { __typename?: 'Mutation', createNotesRoundOffer?: { __typename?: 'CreateNotesRoundOffer', notesRoundOffer?: { __typename?: 'NotesRoundOfferType', id: string } | null } | null };\n\nexport type DeleteNotesRoundOfferMutationVariables = Exact<{\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n}>;\n\n\nexport type DeleteNotesRoundOfferMutation = { __typename?: 'Mutation', deleteNotesRoundOffer?: boolean | null };\n\nexport type ResetNotesRoundOfferMutationVariables = Exact<{\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  keepContracts: Scalars['Boolean']['input'];\n}>;\n\n\nexport type ResetNotesRoundOfferMutation = { __typename?: 'Mutation', resetNotesOffer?: boolean | null };\n\nexport type UpdateNotesOfferPaymentStatusMutationVariables = Exact<{\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  paid: Scalars['CakeDecimal']['input'];\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  notify?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type UpdateNotesOfferPaymentStatusMutation = { __typename?: 'Mutation', updateNotesOfferPaymentStatus?: { __typename?: 'UpdateNotesOfferPaymentStatus', ok?: boolean | null } | null };\n\nexport type InviteNotesOfferMutationVariables = Exact<{\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  sendInvitationEmail: Scalars['Boolean']['input'];\n  email?: InputMaybe<Scalars['CleanString']['input']>;\n  payment?: InputMaybe<Scalars['JSONString']['input']>;\n}>;\n\n\nexport type InviteNotesOfferMutation = { __typename?: 'Mutation', inviteNotesOffer?: { __typename?: 'InviteNotesOffer', ok?: boolean | null } | null };\n\nexport type SettleNotesOfferOfflineMutationVariables = Exact<{\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  principal: Scalars['CakeDecimal']['input'];\n  contract?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  notify?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type SettleNotesOfferOfflineMutation = { __typename?: 'Mutation', settleNotesOfferOffline?: { __typename?: 'SettleNotesOfferOffline', ok?: boolean | null } | null };\n\nexport type IssueNotesMutationVariables = Exact<{\n  shareholderId: Scalars['UUID']['input'];\n  type: Scalars['String']['input'];\n  totalPaid: Scalars['CakeDecimal']['input'];\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  comment?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type IssueNotesMutation = { __typename?: 'Mutation', createNote?: { __typename?: 'CreateNote', note?: { __typename?: 'Note', id: string } | null } | null };\n\nexport type EditNoteMutationVariables = Exact<{\n  noteId: Scalars['NoteCakeType']['input'];\n  principal: Scalars['CakeDecimal']['input'];\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n  comment?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type EditNoteMutation = { __typename?: 'Mutation', editNote?: boolean | null };\n\nexport type IssueOfferNoteMutationVariables = Exact<{\n  offer: Scalars['NotesRoundOfferCakeType']['input'];\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n}>;\n\n\nexport type IssueOfferNoteMutation = { __typename?: 'Mutation', issueOfferNote?: { __typename?: 'IssueOfferNote', note?: { __typename?: 'Note', id: string } | null } | null };\n\nexport type ConvertNoteMutationVariables = Exact<{\n  noteId: Scalars['UUID']['input'];\n  sharetypeId: Scalars['UUID']['input'];\n  pricePerShare: Scalars['CakeDecimal']['input'];\n  valuation?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  date?: InputMaybe<Scalars['Date']['input']>;\n  dryRun: Scalars['Boolean']['input'];\n}>;\n\n\nexport type ConvertNoteMutation = { __typename?: 'Mutation', convertNote?: { __typename?: 'ConvertNote', sharesIssued?: number | null } | null };\n\nexport type ConvertNoteManualMutationVariables = Exact<{\n  noteId: Scalars['UUID']['input'];\n  sharetypeId: Scalars['UUID']['input'];\n  conversionShares: Scalars['BigInt']['input'];\n  totalAmountPaid: Scalars['CakeDecimal']['input'];\n  date?: InputMaybe<Scalars['Date']['input']>;\n}>;\n\n\nexport type ConvertNoteManualMutation = { __typename?: 'Mutation', convertNoteManual?: { __typename?: 'ConvertNoteManual', sharesIssued?: number | null } | null };\n\nexport type CancelNoteMutationVariables = Exact<{\n  noteId: Scalars['UUID']['input'];\n  cancellationType?: InputMaybe<Scalars['CleanString']['input']>;\n  date?: InputMaybe<Scalars['Date']['input']>;\n}>;\n\n\nexport type CancelNoteMutation = { __typename?: 'Mutation', cancelNote?: { __typename?: 'CancelNote', ok?: boolean | null } | null };\n\nexport type SignNoteAgreementOfficeholderMutationVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type SignNoteAgreementOfficeholderMutation = { __typename?: 'Mutation', signNoteAgreementOfficeholder?: { __typename?: 'SignNoteAgreementOfficeholder', urlList?: Array<string | null> | null, signatureRequestId?: string | null, expectedCallbackUrl?: string | null } | null };\n\nexport type ShareholdersWithNoteholdingsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type ShareholdersWithNoteholdingsQuery = { __typename?: 'Query', sharetypes?: Array<{ __typename?: 'Sharetype', id: string } | null> | null, shareholdersWithNoteholdings?: { __typename?: 'PaginatedShareholderHoldingsType', count: number, currentPage: number, notSignedUpCount?: number | null, pageData?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, secondaryName?: string | null, avatar?: string | null, hasLoggedIn?: boolean | null, consideredInvited?: boolean | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null } | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null } | null } | null> | null, trust?: { __typename?: 'TrustType', id: string } | null, notes: Array<{ __typename?: 'Note', id: string, resolution?: NotesNoteResolutionChoices | null, principal?: number | null, discountRate?: number | null, maturityDate?: string | null, interestRate?: number | null, issueDate: string, valuationCap?: number | null, noteType: NotesNoteTypeChoices }> } | null> | null } | null, organisation?: { __typename?: 'Organisation', fundingPhase?: string | null } | null };\n\nexport type CreateNotesRaiseAndOfficeholdersMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  noteType: Scalars['String']['input'];\n  roundInvestmentGoal: Scalars['CakeDecimal']['input'];\n  endDate: Scalars['Date']['input'];\n  signers: Array<OfficeholderInput> | OfficeholderInput;\n  capitalRaisingEventAmount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  discountRate?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  valuationCap?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  interest?: InputMaybe<Interest>;\n  maturityDate?: InputMaybe<Scalars['Date']['input']>;\n  payment?: InputMaybe<Scalars['JSONString']['input']>;\n}>;\n\n\nexport type CreateNotesRaiseAndOfficeholdersMutation = { __typename?: 'Mutation', createNotesRaiseAndOfficeholders?: { __typename?: 'CreateNotesRaiseAndOfficeholders', notesRound?: { __typename?: 'NotesRoundType', id: string } | null } | null };\n\nexport type BulkDeleteNotesMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  noteIds: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n}>;\n\n\nexport type BulkDeleteNotesMutation = { __typename?: 'Mutation', bulkDeleteNotes?: boolean | null };\n\nexport type GetOffboardingsQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n}>;\n\n\nexport type GetOffboardingsQuery = { __typename?: 'Query', offboardings?: { __typename?: 'PaginatedOffboardingOutputType', currentPage: number, count: number, pageData?: Array<{ __typename?: 'OffboardingOutputType', id: string, terminationDate: string, status: OffboardingStatus, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null, employeeData?: { __typename?: 'EmployeeDataType', level: SeEmployeeDataLevelChoices, role: SeEmployeeDataRoleChoices } | null } } | null> | null } | null };\n\nexport type CreateOffboardingMutationVariables = Exact<{\n  shareholderId: Scalars['ShareholderCakeType']['input'];\n  terminationDate: Scalars['Date']['input'];\n  offers: Array<OffboardingEntryInputType> | OffboardingEntryInputType;\n}>;\n\n\nexport type CreateOffboardingMutation = { __typename?: 'Mutation', createOffboarding?: boolean | null };\n\nexport type DeleteOffboardingMutationVariables = Exact<{\n  offboardingId: Scalars['OffboardingCakeType']['input'];\n}>;\n\n\nexport type DeleteOffboardingMutation = { __typename?: 'Mutation', deleteOffboarding?: boolean | null };\n\nexport type ShareholdersToOffboardQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['Int']['input'];\n  itemsPerPage: Scalars['Int']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n  shareholderIdsToExclude?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>>;\n}>;\n\n\nexport type ShareholdersToOffboardQuery = { __typename?: 'Query', shareholdersToOffboard?: { __typename?: 'PaginatedShareholderType', notSignedUpCount?: number | null, count: number, currentPage: number, pageData?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null, employeeData?: { __typename?: 'EmployeeDataType', role: SeEmployeeDataRoleChoices, level: SeEmployeeDataLevelChoices } | null } | null> | null } | null };\n\nexport type ShareholderOffboardingOffersQueryVariables = Exact<{\n  shareholderId: Scalars['ShareholderCakeType']['input'];\n  offboardingDate: Scalars['Date']['input'];\n}>;\n\n\nexport type ShareholderOffboardingOffersQuery = { __typename?: 'Query', shareholderOffboardingOffers?: { __typename?: 'ShareholderOffboardingOffersOutputType', shareholder?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null, employeeData?: { __typename?: 'EmployeeDataType', level: SeEmployeeDataLevelChoices, role: SeEmployeeDataRoleChoices } | null } | null, esopOffers?: Array<{ __typename?: 'EsopOffer', id: string } | null> | null, essOffers?: Array<{ __typename?: 'EssOffer', id: string } | null> | null, rsuOffers?: Array<{ __typename?: 'RsuOfferOutputType', id: string } | null> | null, founderVestingOffers?: Array<{ __typename?: 'FounderVestingOfferOutputType', id: string } | null> | null } | null };\n\nexport type OffboardingDetailsEsopQueryVariables = Exact<{\n  offerId: Scalars['EsopOfferCakeType']['input'];\n}>;\n\n\nexport type OffboardingDetailsEsopQuery = { __typename?: 'Query', offboardingDetailsEsop?: { __typename?: 'EsopOffer', id: string, granted?: number | null, exercised?: number | null, vestablePeriodic?: number | null, vestableMilestone?: number | null, vestedPeriodic?: number | null, vestedMilestone?: number | null, lapsedMilestone?: number | null, lapsedPeriodic?: number | null, availableToExercise?: number | null, availableToVest?: number | null, availableToLapse?: number | null, conversionLockDate?: string | null, country?: string | null, currency?: string | null, calendar?: { __typename?: 'OfferCalendarOutputType', entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, entryType?: string | null }> | null } | null, vestingEvents?: Array<{ __typename?: 'EsopVestingEventType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'EsopTransaction', id: string, transactionDate: string, vestingValue?: number | null, type: EsopEsopTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, reminderDate?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null, offboardSettings?: { __typename?: 'OffboardEventSettingsOutputType', id: string, accelerateAmount: number, fullyLapse: boolean, stopVestingAt: SeOffboardEventSettingsStopVestingAtChoices, repurchaseValueUnvested?: number | null, repurchaseValueVested?: number | null, autoLapse: boolean, complete: boolean } | null, ptepSettings?: { __typename?: 'PtepSettingsOutputType', id: string, sendExerciseReminder: boolean, ptepInterval: { __typename?: 'TimeSliceType', quantity?: number | null, unit?: string | null } } | null } | null };\n\nexport type OffboardingDetailsEssQueryVariables = Exact<{\n  offerId: Scalars['EssOfferCakeType']['input'];\n}>;\n\n\nexport type OffboardingDetailsEssQuery = { __typename?: 'Query', offboardingDetailsEss?: { __typename?: 'EssOffer', id: string, granted?: number | null, exercised?: number | null, vestablePeriodic?: number | null, vestableMilestone?: number | null, vestedPeriodic?: number | null, vestedMilestone?: number | null, lapsedMilestone?: number | null, lapsedPeriodic?: number | null, availableToExercise?: number | null, availableToVest?: number | null, availableToLapse?: number | null, conversionLockDate?: string | null, country?: string | null, currency?: string | null, calendar?: { __typename?: 'OfferCalendarOutputType', entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, entryType?: string | null }> | null } | null, vestingEvents?: Array<{ __typename?: 'EssVestingEventType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'EssTransaction', id: string, transactionDate: string, vestingValue?: number | null, type: EssEssTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, reminderDate?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null, offboardSettings?: { __typename?: 'OffboardEventSettingsOutputType', id: string, accelerateAmount: number, fullyLapse: boolean, stopVestingAt: SeOffboardEventSettingsStopVestingAtChoices, repurchaseValueUnvested?: number | null, repurchaseValueVested?: number | null, autoLapse: boolean, complete: boolean } | null } | null };\n\nexport type OffboardingDetailsRsuQueryVariables = Exact<{\n  offerId: Scalars['RsuOfferCakeType']['input'];\n}>;\n\n\nexport type OffboardingDetailsRsuQuery = { __typename?: 'Query', offboardingDetailsRsu?: { __typename?: 'RsuOfferOutputType', id: string, granted?: number | null, exercised?: number | null, vestablePeriodic?: number | null, vestableMilestone?: number | null, vestedPeriodic?: number | null, vestedMilestone?: number | null, lapsedMilestone?: number | null, lapsedPeriodic?: number | null, availableToExercise?: number | null, availableToVest?: number | null, availableToLapse?: number | null, conversionLockDate?: string | null, country?: string | null, currency?: string | null, calendar?: { __typename?: 'OfferCalendarOutputType', entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, entryType?: string | null }> | null } | null, vestingEvents?: Array<{ __typename?: 'RsuVestingEventOutputType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'RsuTransactionOutputType', id: string, transactionDate: string, vestingValue?: number | null, type: RsuRsuTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, reminderDate?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null, offboardSettings?: { __typename?: 'OffboardEventSettingsOutputType', id: string, accelerateAmount: number, fullyLapse: boolean, stopVestingAt: SeOffboardEventSettingsStopVestingAtChoices, repurchaseValueUnvested?: number | null, repurchaseValueVested?: number | null, autoLapse: boolean, complete: boolean } | null } | null };\n\nexport type OffboardingDetailsFounderVestingQueryVariables = Exact<{\n  offerId: Scalars['FounderVestingOfferCakeType']['input'];\n}>;\n\n\nexport type OffboardingDetailsFounderVestingQuery = { __typename?: 'Query', offboardingDetailsFounderVesting?: { __typename?: 'FounderVestingOfferOutputType', id: string, granted?: number | null, exercised?: number | null, vestablePeriodic?: number | null, vestableMilestone?: number | null, vestedPeriodic?: number | null, vestedMilestone?: number | null, lapsedMilestone?: number | null, lapsedPeriodic?: number | null, availableToExercise?: number | null, availableToVest?: number | null, availableToLapse?: number | null, conversionLockDate?: string | null, country?: string | null, currency?: string | null, calendar?: { __typename?: 'OfferCalendarOutputType', entries?: Array<{ __typename?: 'VestingCalendarOutputEntry', date?: string | null, accumulated?: number | null, vestingValue?: number | null, entryType?: string | null }> | null } | null, vestingEvents?: Array<{ __typename?: 'FounderVestingVestingEventOutputType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'FounderVestingTransactionOutputType', id: string, transactionDate: string, vestingValue?: number | null, type: FoundervestingFounderVestingTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, reminderDate?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null, offboardSettings?: { __typename?: 'OffboardEventSettingsOutputType', id: string, accelerateAmount: number, fullyLapse: boolean, stopVestingAt: SeOffboardEventSettingsStopVestingAtChoices, repurchaseValueUnvested?: number | null, repurchaseValueVested?: number | null, autoLapse: boolean, complete: boolean } | null } | null };\n\nexport type OffboardingQueryVariables = Exact<{\n  offboardingId: Scalars['OffboardingCakeType']['input'];\n}>;\n\n\nexport type OffboardingQuery = { __typename?: 'Query', offboarding?: { __typename?: 'OffboardingOutputType', id: string, terminationDate: string, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null, employeeData?: { __typename?: 'EmployeeDataType', level: SeEmployeeDataLevelChoices, role: SeEmployeeDataRoleChoices } | null }, offboardeventsettingsSet?: Array<{ __typename?: 'OffboardEventSettingsOutputType', id: string, accelerateAmount: number, fullyLapse: boolean, stopVestingAt: SeOffboardEventSettingsStopVestingAtChoices, repurchaseValueUnvested?: number | null, repurchaseValueVested?: number | null, essoffer?: { __typename?: 'EssOffer', id: string } | null, esopoffer?: { __typename?: 'EsopOffer', id: string } | null, rsuoffer?: { __typename?: 'RsuOfferOutputType', id: string } | null, foundervestingoffer?: { __typename?: 'FounderVestingOfferOutputType', id: string } | null } | null> | null } | null };\n\nexport type EditOffboardingMutationVariables = Exact<{\n  offboardingId: Scalars['OffboardingCakeType']['input'];\n  terminationDate: Scalars['Date']['input'];\n  offers: Array<OffboardingEntryInputType> | OffboardingEntryInputType;\n}>;\n\n\nexport type EditOffboardingMutation = { __typename?: 'Mutation', editOffboarding?: boolean | null };\n\nexport type UpdateHubspotMobileNumberMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  mobileNumber: Scalars['CleanString']['input'];\n}>;\n\n\nexport type UpdateHubspotMobileNumberMutation = { __typename?: 'Mutation', updateHubspotMobileNumber?: boolean | null };\n\nexport type AddShareholderIssueSharesMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareholderIssueSharesInputList: Array<InputMaybe<ShareholderIssueSharesInput>> | InputMaybe<ShareholderIssueSharesInput>;\n}>;\n\n\nexport type AddShareholderIssueSharesMutation = { __typename?: 'Mutation', addShareholderIssueShares?: Array<{ __typename?: 'Shareholder', id: string, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null } | null> | null };\n\nexport type OnboardingShownMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type OnboardingShownMutation = { __typename?: 'Mutation', onboardingShown?: boolean | null };\n\nexport type GetStepAddShareholdersDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetStepAddShareholdersDataQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', creationIntent?: OrganisationsOrganisationCreationIntentChoices | null, sharetypeSet: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string }> } | null };\n\nexport type GetOrganisationDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetOrganisationDataQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', id: string, name: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, fundingPhase?: string | null, created: string, shareCertificateType: OrganisationsOrganisationShareCertificateTypeChoices, logoImage?: string | null, companyType?: string | null, companyDetails?:\n      | { __typename?: 'AuCompanyDetailsField', acn?: string | null, registrationLocation?: string | null, registeredAgentName?: string | null, registeredAgentEmail?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'CaCompanyDetailsField', bn?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'EeCompanyDetailsField', brc?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'GbCompanyDetailsField', crn?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'InCompanyDetailsField', cin?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'NzCompanyDetailsField', nzbn?: string | null, registeredAgentName?: string | null, registeredAgentEmail?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'SgCompanyDetailsField', uen?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'UsCompanyDetailsField', stateOfRegistration: InternationalUsCompanyDetailsStateOfRegistrationChoices, ein?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n     | null } | null };\n\nexport type OrganisationShareholdingTransactionsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  filterType?: InputMaybe<Scalars['String']['input']>;\n  faultyOnly?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type OrganisationShareholdingTransactionsQuery = { __typename?: 'Query', organisationShareholdingTransactions?: { __typename?: 'PaginatedShareholdingTransaction', currentPage: number, count: number, pageData?: Array<{ __typename?: 'ShareholdingTransaction', transactionDate: string, shares?: number | null, amount?: number | null, paidInTransfer?: number | null, shareSplitFactor?: number | null, lastComment?: string | null, unpaid?: number | null, error?: string | null, attachedDocumentId?: string | null, attachedDocumentName?: string | null, transactionId: string, transactionType: SeShareholdingTransactionTypeChoices, sharetype: { __typename?: 'Sharetype', id: string, symbol: string }, shareholder?: { __typename?: 'Shareholder', id: string, displayName?: string | null, secondaryName?: string | null, avatar?: string | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null } | null, trust?: { __typename?: 'TrustType', id: string } | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', identifierType?: IdentifierTypeOutputField | null } | null } | null> | null } | null, beneficiary?: { __typename?: 'Shareholder', id: string, displayName?: string | null } | null, certificate?: { __typename?: 'Document', id: string, name?: string | null, certificateNumber?: number | null } | null } | null> | null } | null, organisation?: { __typename?: 'Organisation', shareCertificateType: OrganisationsOrganisationShareCertificateTypeChoices, lastCertificateNumber?: number | null } | null };\n\nexport type GetOrganisationNotesTransactionsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetOrganisationNotesTransactionsQuery = { __typename?: 'Query', organisationNotesTransactions?: { __typename?: 'PaginatedNoteTransaction', currentPage: number, count: number, pageData?: Array<{ __typename?: 'NoteTransaction', transactionDate: string, transactionId: string, transactionType: NotesNoteTransactionTypeChoices, note: { __typename?: 'Note', type: NotesNoteTypeChoices, principal?: number | null, interestRate?: number | null, discountRate?: number | null, valuationCap?: number | null }, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, secondaryName?: string | null, avatar?: string | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null } | null, trust?: { __typename?: 'TrustType', id: string } | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, companyData?: { __typename?: 'CompanyDataType', identifierType?: IdentifierTypeOutputField | null } | null } | null> | null } } | null> | null } | null };\n\nexport type GetOrganisationSharetypeDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetOrganisationSharetypeDataQuery = { __typename?: 'Query', sharetypes?: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string, voting: boolean, dividend: boolean } | null> | null };\n\nexport type GetOrganisationSharetypesAndTotalsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetOrganisationSharetypesAndTotalsQuery = { __typename?: 'Query', sharetypes?: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string, voting: boolean, dividend: boolean, weight?: number | null, authorisedShares?: number | null, totals?: { __typename?: 'SharetypeTotals', totalShares?: number | null, amountRaised?: number | null, totalDue?: number | null } | null } | null> | null };\n\nexport type GetOrganisationOfficeholdersDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetOrganisationOfficeholdersDataQuery = { __typename?: 'Query', officeholders?: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, avatar?: string | null, signer?: SeOfficeholderSignerChoices | null, signature?: string | null, roles: Array<{ __typename?: 'OfficeholderRoleType', role: SeOfficeholderRoleRoleChoices, name?: string | null }> } | null> | null };\n\nexport type GetOrganisationOfficeholdersAndRolesQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n  excludeByIds?: InputMaybe<Array<Scalars['UUID']['input']> | Scalars['UUID']['input']>;\n}>;\n\n\nexport type GetOrganisationOfficeholdersAndRolesQuery = { __typename?: 'Query', officeholders?: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, avatar?: string | null, signer?: SeOfficeholderSignerChoices | null, signature?: string | null, roles: Array<{ __typename?: 'OfficeholderRoleType', role: SeOfficeholderRoleRoleChoices, name?: string | null }> } | null> | null, availableOfficeholderRoles?: Array<{ __typename?: 'RoleType', role?: string | null, name?: string | null } | null> | null };\n\nexport type GetOrganisationOfficeholdersDataSimpleQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetOrganisationOfficeholdersDataSimpleQuery = { __typename?: 'Query', officeholders?: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, avatar?: string | null } | null> | null };\n\nexport type GetOrganisationAvailableOfficeholderRolesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetOrganisationAvailableOfficeholderRolesQuery = { __typename?: 'Query', availableOfficeholderRoles?: Array<{ __typename?: 'RoleType', role?: string | null, name?: string | null } | null> | null, availableOrganisationRoles?: { __typename?: 'AvailableOrganisationRoles', roles?: Array<{ __typename?: 'RoleWithDescription', role?: string | null, description?: string | null } | null> | null } | null };\n\nexport type CreateOrganisationSignupMutationVariables = Exact<{\n  name: Scalars['CleanString']['input'];\n  country: Scalars['CleanString']['input'];\n  creationIntents?: InputMaybe<Array<Scalars['CleanString']['input']> | Scalars['CleanString']['input']>;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  fundingPhase?: InputMaybe<Scalars['CleanString']['input']>;\n  companySize?: InputMaybe<Scalars['CleanString']['input']>;\n  creatorRole?: InputMaybe<Scalars['CleanString']['input']>;\n  experienceLevel?: InputMaybe<Scalars['CleanString']['input']>;\n  reasonForOnboarding?: InputMaybe<Scalars['CleanString']['input']>;\n  sourceOfReferral?: InputMaybe<Scalars['CleanString']['input']>;\n  interestedIn409a?: InputMaybe<Scalars['Boolean']['input']>;\n  mobileNumber?: InputMaybe<Scalars['CleanString']['input']>;\n  copilots?: InputMaybe<Array<InputMaybe<InvitedUserInput>> | InputMaybe<InvitedUserInput>>;\n}>;\n\n\nexport type CreateOrganisationSignupMutation = { __typename?: 'Mutation', createOrganisationSignup?: { __typename?: 'CreateOrganisationSignup', organisation?: { __typename?: 'Organisation', id: string } | null } | null };\n\nexport type AddNewOfficeholderMutationVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  officeholder: OfficeholderInput;\n}>;\n\n\nexport type AddNewOfficeholderMutation = { __typename?: 'Mutation', addOfficeholder?: { __typename?: 'AddOfficeholder', officeholder?: { __typename?: 'Officeholder', id: string } | null } | null };\n\nexport type AddOrUpdateCompanySignersMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  signers: Array<AddOrUpdateCompanySignersInput> | AddOrUpdateCompanySignersInput;\n}>;\n\n\nexport type AddOrUpdateCompanySignersMutation = { __typename?: 'Mutation', addOrUpdateCompanySigners?: boolean | null };\n\nexport type AddOrRenewSupportRoleMutationVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type AddOrRenewSupportRoleMutation = { __typename?: 'Mutation', addOrRenewSupportRole?: boolean | null };\n\nexport type UpdateOrganisationUploadInProgressMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  uploadInProgress: Scalars['Boolean']['input'];\n}>;\n\n\nexport type UpdateOrganisationUploadInProgressMutation = { __typename?: 'Mutation', updateOrganisationUploadInProgress?: boolean | null };\n\nexport type UpdateOrganisationHideUpcomingInvoiceMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  hideUpcomingInvoice: Scalars['Boolean']['input'];\n}>;\n\n\nexport type UpdateOrganisationHideUpcomingInvoiceMutation = { __typename?: 'Mutation', updateOrganisationHideUpcomingInvoice?: boolean | null };\n\nexport type UpdateOrganisationBasicMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type UpdateOrganisationBasicMutation = { __typename?: 'Mutation', updateOrganisationBasic?: { __typename?: 'UpdateOrganisationBasic', organisation?: { __typename?: 'Organisation', id: string } | null } | null };\n\nexport type UpdateOrganisationAuMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n  auCompanyDetails: AuCompanyDetailsInput;\n}>;\n\n\nexport type UpdateOrganisationAuMutation = { __typename?: 'Mutation', updateOrganisationAu?: { __typename?: 'UpdateOrganisationAu', organisation?: { __typename?: 'Organisation', id: string, name: string } | null } | null };\n\nexport type UpdateOrganisationSgMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n  sgCompanyDetails: SgCompanyDetailsInput;\n}>;\n\n\nexport type UpdateOrganisationSgMutation = { __typename?: 'Mutation', updateOrganisationSg?: { __typename?: 'UpdateOrganisationSg', organisation?: { __typename?: 'Organisation', id: string } | null } | null };\n\nexport type UpdateOrganisationUsMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n  usCompanyDetails: UsCompanyDetailsInput;\n}>;\n\n\nexport type UpdateOrganisationUsMutation = { __typename?: 'Mutation', updateOrganisationUs?: { __typename?: 'UpdateOrganisationUs', organisation?: { __typename?: 'Organisation', id: string } | null } | null };\n\nexport type UpdateOrganisationGbMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n  gbCompanyDetails: GbCompanyDetailsInput;\n}>;\n\n\nexport type UpdateOrganisationGbMutation = { __typename?: 'Mutation', updateOrganisationGb?: { __typename?: 'UpdateOrganisationGb', organisation?: { __typename?: 'Organisation', id: string } | null } | null };\n\nexport type UpdateOrganisationNzMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  nzCompanyDetails: NzCompanyDetailsInput;\n}>;\n\n\nexport type UpdateOrganisationNzMutation = { __typename?: 'Mutation', updateOrganisationNz?: { __typename?: 'UpdateOrganisationNz', organisation?: { __typename?: 'Organisation', id: string } | null } | null };\n\nexport type UpdateOrganisationInMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  inCompanyDetails: InCompanyDetailsInput;\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type UpdateOrganisationInMutation = { __typename?: 'Mutation', updateOrganisationIn?: { __typename?: 'UpdateOrganisationIn', organisation?: { __typename?: 'Organisation', id: string } | null } | null };\n\nexport type UpdateOrganisationCaMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  shareCertificateType?: InputMaybe<Scalars['CleanString']['input']>;\n  caCompanyDetails: CaCompanyDetailsInput;\n}>;\n\n\nexport type UpdateOrganisationCaMutation = { __typename?: 'Mutation', updateOrganisationCa?: { __typename?: 'UpdateOrganisationCa', organisation?: { __typename?: 'Organisation', id: string } | null } | null };\n\nexport type UpdateOrganisationEeMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  currency?: InputMaybe<Scalars['CleanString']['input']>;\n  companyType?: InputMaybe<Scalars['CleanString']['input']>;\n  eeCompanyDetails: EeCompanyDetailsInput;\n}>;\n\n\nexport type UpdateOrganisationEeMutation = { __typename?: 'Mutation', updateOrganisationEe?: { __typename?: 'UpdateOrganisationEe', organisation?: { __typename?: 'Organisation', id: string } | null } | null };\n\nexport type UpdateTransactionUnpaidAmountMutationVariables = Exact<{\n  transaction: Scalars['ShareholdingTransactionCakeType']['input'];\n  unpaidAmount: Scalars['CakeDecimal']['input'];\n}>;\n\n\nexport type UpdateTransactionUnpaidAmountMutation = { __typename?: 'Mutation', updateTransactionUnpaidAmount?: { __typename?: 'UpdateTransactionUnpaidAmount', ok?: boolean | null } | null };\n\nexport type UpdateOrganisationFundingPhaseMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  fundingPhase: Scalars['CleanString']['input'];\n}>;\n\n\nexport type UpdateOrganisationFundingPhaseMutation = { __typename?: 'Mutation', updateOrganisationFundingPhase?: boolean | null };\n\nexport type UpdateOfficeholderMutationVariables = Exact<{\n  updateOfficeholderData: UpdateOfficeholderData;\n}>;\n\n\nexport type UpdateOfficeholderMutation = { __typename?: 'Mutation', updateOfficeholder?: { __typename?: 'UpdateOfficeholder', officeholder?: { __typename?: 'Officeholder', id: string, name: string, email?: string | null, signer?: SeOfficeholderSignerChoices | null, roles: Array<{ __typename?: 'OfficeholderRoleType', role: SeOfficeholderRoleRoleChoices, name?: string | null }> } | null } | null };\n\nexport type UpdateSharetypeMutationVariables = Exact<{\n  updateSharetypeData: UpdateSharetypeData;\n}>;\n\n\nexport type UpdateSharetypeMutation = { __typename?: 'Mutation', updateSharetype?: { __typename?: 'UpdateSharetype', sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string, voting: boolean, dividend: boolean, authorisedShares?: number | null } | null } | null };\n\nexport type AddNewSharetypeMutationVariables = Exact<{\n  createSharetypeData: CreateShareTypeInput;\n}>;\n\n\nexport type AddNewSharetypeMutation = { __typename?: 'Mutation', createShareType?: { __typename?: 'CreateShareType', sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } | null };\n\nexport type DeleteTransactionsMutationVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  transactionIds: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n  transactionType: Scalars['String']['input'];\n}>;\n\n\nexport type DeleteTransactionsMutation = { __typename?: 'Mutation', deleteTransactions?: boolean | null };\n\nexport type DeleteOfficeholderMutationVariables = Exact<{\n  officeholder: Scalars['OfficeholderCakeType']['input'];\n}>;\n\n\nexport type DeleteOfficeholderMutation = { __typename?: 'Mutation', deleteOfficeholder?: { __typename?: 'DeleteOfficeholder', organisation?: { __typename?: 'Organisation', id: string } | null } | null };\n\nexport type DeleteSharetypeMutationVariables = Exact<{\n  sharetype: Scalars['SharetypeCakeType']['input'];\n}>;\n\n\nexport type DeleteSharetypeMutation = { __typename?: 'Mutation', deleteSharetype?: { __typename?: 'DeleteSharetype', ok?: boolean | null } | null };\n\nexport type OrganisationSupportSearchQueryVariables = Exact<{\n  search: Scalars['String']['input'];\n}>;\n\n\nexport type OrganisationSupportSearchQuery = { __typename?: 'Query', organisationSupportSearch?: Array<{ __typename?: 'Organisation', id: string, name: string, license?: { __typename?: 'LicenseInfoType', internalId?: string | null } | null } | null> | null };\n\nexport type DeleteSupportRolesMutationVariables = Exact<{\n  roleIdList: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n}>;\n\n\nexport type DeleteSupportRolesMutation = { __typename?: 'Mutation', deleteSupportRoles?: boolean | null };\n\nexport type DeleteAllSupportRolesMutationVariables = Exact<{\n  expiredOnly?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type DeleteAllSupportRolesMutation = { __typename?: 'Mutation', deleteAllSupportRoles?: boolean | null };\n\nexport type GetSupportAdminEntriesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetSupportAdminEntriesQuery = { __typename?: 'Query', supportAdminEntries?: Array<{ __typename?: 'OrganisationUserRoleType', id: string, role: OrganisationsOrganisationUserRoleRoleChoices, expire?: string | null, organisation: { __typename?: 'Organisation', id: string, name: string, uploadInProgress: boolean, hideUpcomingInvoice: boolean, logoImageInternal?: string | null, logoImage?: string | null, logoDeprecated: string, license?: { __typename?: 'LicenseInfoType', internalId?: string | null, investorCount?: number | null, maxInvestors?: number | null } | null } } | null> | null };\n\nexport type GetSupportedShareholdersQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetSupportedShareholdersQuery = { __typename?: 'Query', getSupportedShareholders?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, organisation: { __typename?: 'Organisation', name: string } } | null> | null };\n\nexport type AddSupportToShareholderMutationVariables = Exact<{\n  shareholder: Scalars['ShareholderCakeType']['input'];\n}>;\n\n\nexport type AddSupportToShareholderMutation = { __typename?: 'Mutation', addSupportToShareholder?: boolean | null };\n\nexport type DeleteSupportToShareholderMutationVariables = Exact<{\n  shareholder: Scalars['ShareholderCakeType']['input'];\n}>;\n\n\nexport type DeleteSupportToShareholderMutation = { __typename?: 'Mutation', deleteSupportToShareholder?: boolean | null };\n\nexport type SupportDeleteOrganisationMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  confirmation: Scalars['String']['input'];\n  reason: Scalars['CleanString']['input'];\n}>;\n\n\nexport type SupportDeleteOrganisationMutation = { __typename?: 'Mutation', supportDeleteOrganisation?: boolean | null };\n\nexport type UserOrganisationsSupportSearchQueryVariables = Exact<{\n  userEmail?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type UserOrganisationsSupportSearchQuery = { __typename?: 'Query', userOrganisationsSupportSearch?: Array<{ __typename?: 'UserAssociatedOrganisationsType', organisationId?: string | null, organisationName?: string | null, role?: string | null } | null> | null };\n\nexport type OrganisationPreDeletionReportQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type OrganisationPreDeletionReportQuery = { __typename?: 'Query', organisationPreDeletionReport?: { __typename?: 'OrganisationPreDeletionReportType', creationDate?: string | null, dateOfCurrentSubscription?: string | null, hasCancelled?: boolean | null, isPaused?: boolean | null, hasPausedBefore?: boolean | null, numberOfFounderAppUsers?: number | null, numberOfStakeholders?: number | null, stakeholdersInCake?: number | null, numberOfOffers?: number | null, numberOfFiles?: number | null } | null };\n\nexport type GetTeamDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetTeamDataQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', usersWithAggregatedRoles?: Array<{ __typename?: 'UserWithAggregatedRoles', role?: string | null, position?: string | null, user?: { __typename?: 'UserType', id: string, isLoggedInUser?: boolean | null, email: string, name?: string | null, picture: string } | null } | null> | null, license?: { __typename?: 'LicenseInfoType', billingEmail?: string | null, billingMobile?: string | null } | null } | null, availableOrganisationRoles?: { __typename?: 'AvailableOrganisationRoles', roles?: Array<{ __typename?: 'RoleWithDescription', role?: string | null, description?: string | null } | null> | null } | null, availableOrganisationPositions?: { __typename?: 'AvailableOrganisationPositions', positions?: Array<{ __typename?: 'PositionWithDescription', position?: string | null, description?: string | null } | null> | null } | null, officeholders?: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, avatar?: string | null } | null> | null, getInvitedUsers?: Array<{ __typename?: 'EmailSenderType', id: string, payloadInviteEmail?: string | null, payloadRole?: string | null, payloadPosition?: string | null } | null> | null };\n\nexport type GetInvitedUsersQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetInvitedUsersQuery = { __typename?: 'Query', getInvitedUsers?: Array<{ __typename?: 'EmailSenderType', id: string, payloadInviteEmail?: string | null, payloadRole?: string | null, payloadPosition?: string | null } | null> | null };\n\nexport type GetUserOrganisationsQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserOrganisationsQuery = { __typename?: 'Query', viewEditOrganisations?: Array<{ __typename?: 'Organisation', id: string, created: string, name: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, logoImageInternal?: string | null, logoImage?: string | null, logoDeprecated: string, userRoles?: Array<{ __typename?: 'OrganisationUserRoleType', role: OrganisationsOrganisationUserRoleRoleChoices } | null> | null, license?: { __typename?: 'LicenseInfoType', internalId?: string | null } | null, partner?: { __typename?: 'CakePartner', logo: string } | null } | null> | null };\n\nexport type GetUserAdminOrganisationsQueryVariables = Exact<{\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetUserAdminOrganisationsQuery = { __typename?: 'Query', adminOrganisations?: Array<{ __typename?: 'Organisation', id: string, name: string, logo: string, created: string, modified: string, usersWithAggregatedRoles?: Array<{ __typename?: 'UserWithAggregatedRoles', role?: string | null, user?: { __typename?: 'UserType', id: string, isLoggedInUser?: boolean | null, email: string, name?: string | null, picture: string } | null } | null> | null } | null> | null, availableOrganisationRoles?: { __typename?: 'AvailableOrganisationRoles', roles?: Array<{ __typename?: 'RoleWithDescription', role?: string | null, description?: string | null } | null> | null } | null };\n\nexport type InviteUsersMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  invitedUsers: Array<InputMaybe<InvitedUserInput>> | InputMaybe<InvitedUserInput>;\n}>;\n\n\nexport type InviteUsersMutation = { __typename?: 'Mutation', inviteUsers?: { __typename?: 'InviteUsers', invites?: Array<{ __typename?: 'EmailSenderType', id: string, payloadInviteEmail?: string | null, payloadRole?: string | null, payloadPosition?: string | null } | null> | null } | null };\n\nexport type InviteJoinCakeMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  investorIds: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n  emailsForInvestors?: InputMaybe<Array<InvitedShareholderEmailInput> | InvitedShareholderEmailInput>;\n  selectionSearch?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type InviteJoinCakeMutation = { __typename?: 'Mutation', inviteJoinCake?: { __typename?: 'InviteJoinCake', numInvited?: number | null } | null };\n\nexport type SendTestTransactionalEmailMutationVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  templateSlug: CustomerIoMailTemplates;\n}>;\n\n\nexport type SendTestTransactionalEmailMutation = { __typename?: 'Mutation', sendTestTransactionalEmail?: { __typename?: 'SendTestTransactionalEmail', ok?: boolean | null } | null };\n\nexport type UpdateOrganisationUserRoleMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  userId: Scalars['UserCakeType']['input'];\n  role: Scalars['CleanString']['input'];\n  position: Scalars['CleanString']['input'];\n}>;\n\n\nexport type UpdateOrganisationUserRoleMutation = { __typename?: 'Mutation', updateOrganisationUserRole?: string | null };\n\nexport type ConfirmUserInviteMutationVariables = Exact<{\n  inviteId: Scalars['UUID']['input'];\n  code: Scalars['String']['input'];\n}>;\n\n\nexport type ConfirmUserInviteMutation = { __typename?: 'Mutation', confirmUserInvite?: { __typename?: 'ConfirmUserInvite', ok?: boolean | null } | null };\n\nexport type ClearUserInviteSenderMutationVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type ClearUserInviteSenderMutation = { __typename?: 'Mutation', clearUserInviteSender?: boolean | null };\n\nexport type RevokeUserInvitationMutationVariables = Exact<{\n  invite: Scalars['EmailSenderCakeType']['input'];\n}>;\n\n\nexport type RevokeUserInvitationMutation = { __typename?: 'Mutation', revokeUserInvitation?: boolean | null };\n\nexport type RemoveOrganisationUserRolesMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  userId: Scalars['UserCakeType']['input'];\n}>;\n\n\nexport type RemoveOrganisationUserRolesMutation = { __typename?: 'Mutation', removeOrganisationUserRoles?: Array<string | null> | null };\n\nexport type GetCakeGroupUsersQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  filterByGroupId?: InputMaybe<Scalars['UUID']['input']>;\n}>;\n\n\nexport type GetCakeGroupUsersQuery = { __typename?: 'Query', cakeGroups?: Array<{ __typename?: 'CakeGroupType', id: string, name?: string | null, groupType: SeCakeGroupGroupTypeChoices, users?: Array<{ __typename?: 'GroupUser', name?: string | null, email?: string | null, avatar?: string | null, userId?: string | null, userType?: string | null } | null> | null } | null> | null };\n\nexport type GetCakeGroupsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetCakeGroupsQuery = { __typename?: 'Query', cakeGroups?: Array<{ __typename?: 'CakeGroupType', id: string, name?: string | null, groupType: SeCakeGroupGroupTypeChoices, count?: number | null } | null> | null };\n\nexport type GetCakeGroupsSimpleQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetCakeGroupsSimpleQuery = { __typename?: 'Query', cakeGroups?: Array<{ __typename?: 'CakeGroupType', id: string, name?: string | null } | null> | null };\n\nexport type GetAvailableUsersForCakeGroupQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  excludeIds?: InputMaybe<Array<Scalars['UUID']['input']> | Scalars['UUID']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type GetAvailableUsersForCakeGroupQuery = { __typename?: 'Query', getAvailableUsersForCakeGroup?: Array<{ __typename?: 'GroupUser', name?: string | null, email?: string | null, avatar?: string | null, userId?: string | null, userType?: string | null } | null> | null };\n\nexport type GetCakeGroupsWithShareholdersQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetCakeGroupsWithShareholdersQuery = { __typename?: 'Query', cakeGroups?: Array<{ __typename?: 'CakeGroupType', id: string, name?: string | null, groupType: SeCakeGroupGroupTypeChoices, count?: number | null } | null> | null };\n\nexport type CreateCakeGroupMutationVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  groupName: Scalars['String']['input'];\n  parentGroupId?: InputMaybe<Scalars['UUID']['input']>;\n}>;\n\n\nexport type CreateCakeGroupMutation = { __typename?: 'Mutation', createCakeGroup?: { __typename?: 'CreateCakeGroup', ok?: boolean | null } | null };\n\nexport type UpdateCakeGroupMutationVariables = Exact<{\n  groupId: Scalars['UUID']['input'];\n  groupName: Scalars['String']['input'];\n  toAdd?: InputMaybe<Array<GroupUserInputType> | GroupUserInputType>;\n  toRemove?: InputMaybe<Array<GroupUserInputType> | GroupUserInputType>;\n}>;\n\n\nexport type UpdateCakeGroupMutation = { __typename?: 'Mutation', updateCakeGroup?: { __typename?: 'UpdateCakeGroup', ok?: boolean | null } | null };\n\nexport type DeleteCakeGroupMutationVariables = Exact<{\n  groupId: Scalars['UUID']['input'];\n}>;\n\n\nexport type DeleteCakeGroupMutation = { __typename?: 'Mutation', deleteCakeGroup?: { __typename?: 'DeleteCakeGroup', ok?: boolean | null } | null };\n\nexport type HasPendingActionsQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type HasPendingActionsQuery = { __typename?: 'Query', actionItems?: { __typename?: 'PaginatedActionItems', count: number } | null };\n\nexport type PlatformVersionQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type PlatformVersionQuery = { __typename?: 'Query', platformVersion?: string | null };\n\nexport type GetValuationsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetValuationsQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', valuationVisibleToShareholders?: boolean | null, valuationVisibleToOptionholders?: boolean | null, ownershipVisibleToShareholders?: boolean | null, ownershipVisibleToOptionholders?: boolean | null, currency: OrganisationsOrganisationCurrencyChoices, valuations?: Array<{ __typename?: 'ValuationType', id: string, valuation?: number | null, date: string, round?: OrganisationsValuationRoundChoices | null } | null> | null } | null };\n\nexport type GetValuationQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  date?: InputMaybe<Scalars['Date']['input']>;\n}>;\n\n\nexport type GetValuationQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', valuationAt?: { __typename?: 'ValuationType', id: string, valuation?: number | null, date: string, round?: OrganisationsValuationRoundChoices | null } | null } | null };\n\nexport type AddValuationMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  valuation: Scalars['CakeDecimal']['input'];\n  date: Scalars['Date']['input'];\n  round?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type AddValuationMutation = { __typename?: 'Mutation', addValuation?: { __typename?: 'ValuationType', id: string, valuation?: number | null, date: string, round?: OrganisationsValuationRoundChoices | null } | null };\n\nexport type Send409aProviderNotificationMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type Send409aProviderNotificationMutation = { __typename?: 'Mutation', send409aProviderNotification?: boolean | null };\n\nexport type UpdateOneTimeAddonStatusMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  stripeId: Scalars['CleanString']['input'];\n  status: Scalars['CleanString']['input'];\n}>;\n\n\nexport type UpdateOneTimeAddonStatusMutation = { __typename?: 'Mutation', updateOneTimeAddonStatus?: boolean | null };\n\nexport type DeleteValuationMutationVariables = Exact<{\n  valuation: Scalars['ValuationCakeType']['input'];\n}>;\n\n\nexport type DeleteValuationMutation = { __typename?: 'Mutation', deleteValuation?: { __typename?: 'DeleteValuation', ok?: boolean | null } | null };\n\nexport type GetCakePlansV5QueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  allowDowngrade?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type GetCakePlansV5Query = { __typename?: 'Query', getCakePlansV5?: Array<{ __typename?: 'CakePlanType', internalId?: string | null, price?: number | null, isAvailable?: boolean | null, currency?: string | null, perheadPrice?: number | null, perheadIncluded?: number | null, availableAddons?: Array<{ __typename?: 'CakeAddonType', internalId?: string | null, price?: number | null, canBePurchased?: boolean | null } | null> | null } | null> | null };\n\nexport type GetOneTimeAddonPriceQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  addon: Scalars['CleanString']['input'];\n}>;\n\n\nexport type GetOneTimeAddonPriceQuery = { __typename?: 'Query', getOneTimeAddonPrice?: number | null };\n\nexport type GetOrganisationBillingDetailsQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetOrganisationBillingDetailsQuery = { __typename?: 'Query', getBillingDetails?: { __typename?: 'BillingDetails', ccLast4?: string | null } | null };\n\nexport type GetCouponDataQueryVariables = Exact<{\n  coupon: Scalars['CleanString']['input'];\n}>;\n\n\nexport type GetCouponDataQuery = { __typename?: 'Query', getCouponData?: { __typename?: 'CouponType', isPercentage?: boolean | null, value?: number | null, durationInMonths?: number | null, duration?: string | null } | null };\n\nexport type UpgradeSubscriptionMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  targetPlanId: Scalars['String']['input'];\n  stripeCoupon?: InputMaybe<Scalars['CleanString']['input']>;\n  stripePaymentId?: InputMaybe<Scalars['String']['input']>;\n  addons?: InputMaybe<Array<Scalars['String']['input']> | Scalars['String']['input']>;\n}>;\n\n\nexport type UpgradeSubscriptionMutation = { __typename?: 'Mutation', upgradeSubscription?: { __typename?: 'UpgradeSubscription', ok?: boolean | null, previousPlan?: string | null, targetPlan?: string | null } | null };\n\nexport type BuyOneOff409AMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type BuyOneOff409AMutation = { __typename?: 'Mutation', buyOneOff409A?: boolean | null };\n\nexport type UpdateCreditCardMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  stripeId: Scalars['CleanString']['input'];\n}>;\n\n\nexport type UpdateCreditCardMutation = { __typename?: 'Mutation', updateCreditCard?: { __typename?: 'StripeInvoicePaymentAttemptResult', payCount?: number | null, pendingInvoiceIds?: Array<string | null> | null } | null };\n\nexport type PayPendingInvoicesMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type PayPendingInvoicesMutation = { __typename?: 'Mutation', payPendingInvoices?: { __typename?: 'StripeInvoicePaymentAttemptResult', payCount?: number | null, pendingInvoiceIds?: Array<string | null> | null } | null };\n\nexport type GetBillingAvatarQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetBillingAvatarQuery = { __typename?: 'Query', getBillingAvatar?: { __typename?: 'BillingAvatar', name?: string | null, picture?: string | null } | null };\n\nexport type UpdateBillingContactMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  email: Scalars['CleanString']['input'];\n  mobile?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type UpdateBillingContactMutation = { __typename?: 'Mutation', updateBillingContact?: boolean | null };\n\nexport type PauseSubscriptionMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  pause: Scalars['Boolean']['input'];\n  reasonForPause?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type PauseSubscriptionMutation = { __typename?: 'Mutation', pauseSubscription?: boolean | null };\n\nexport type RequestCancelSubscriptionMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  reason: Scalars['CleanString']['input'];\n  competitorName?: InputMaybe<Scalars['String']['input']>;\n  feedback?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type RequestCancelSubscriptionMutation = { __typename?: 'Mutation', requestCancelSubscription: string };\n\nexport type GetStripeCustomerIdQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetStripeCustomerIdQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', stripeCustomerId?: string | null } | null };\n\nexport type UnusedTimeQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type UnusedTimeQuery = { __typename?: 'Query', unusedTime?: number | null };\n\nexport type UpdateVisibilitySettingsMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  valuationVisibleToShareholders: Scalars['Boolean']['input'];\n  valuationVisibleToOptionholders: Scalars['Boolean']['input'];\n  ownershipVisibleToShareholders: Scalars['Boolean']['input'];\n  ownershipVisibleToOptionholders: Scalars['Boolean']['input'];\n}>;\n\n\nexport type UpdateVisibilitySettingsMutation = { __typename?: 'Mutation', updateVisibilitySettings?: boolean | null };\n\nexport type ResetUserMfaEnrollMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  userId: Scalars['UUID']['input'];\n}>;\n\n\nexport type ResetUserMfaEnrollMutation = { __typename?: 'Mutation', resetUserMfaEnroll?: boolean | null };\n\nexport type WhitelistUserMfaMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  userId: Scalars['UUID']['input'];\n}>;\n\n\nexport type WhitelistUserMfaMutation = { __typename?: 'Mutation', whitelistUserMfa?: boolean | null };\n\nexport type ToggleMfaRequiredMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  required: Scalars['Boolean']['input'];\n  otpCode?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type ToggleMfaRequiredMutation = { __typename?: 'Mutation', toggleMfaRequired?: { __typename?: 'ToggleMfaRequired', required?: boolean | null, mfaSetupNeeded?: { __typename?: 'MfaSetupOutputType', configUrl?: string | null, qrcodeImage?: string | null } | null } | null };\n\nexport type OrganisationMfaStatusQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type OrganisationMfaStatusQuery = { __typename?: 'Query', organisationMfaStatus?: boolean | null };\n\nexport type GetUsersWithMfaQueryVariables = Exact<{\n  organisation?: InputMaybe<Scalars['OrganisationCakeType']['input']>;\n  page: Scalars['Int']['input'];\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetUsersWithMfaQuery = { __typename?: 'Query', usersWithMfa?: { __typename?: 'PaginatedUserType', currentPage: number, count: number, pageData?: Array<{ __typename?: 'UserType', hasEnrolledMfa?: boolean | null, email: string, firstName: string, lastName: string, picture: string, id: string, mfaWhitelist?: boolean | null } | null> | null } | null };\n\nexport type SendRequest409aCallbackMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  mobileNumber: Scalars['String']['input'];\n}>;\n\n\nexport type SendRequest409aCallbackMutation = { __typename?: 'Mutation', sendRequest409aCallback?: boolean | null };\n\nexport type SendActivityLogFeedbackMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  activityLogFeedback: Scalars['CleanString']['input'];\n}>;\n\n\nexport type SendActivityLogFeedbackMutation = { __typename?: 'Mutation', sendActivityLogFeedback?: boolean | null };\n\nexport type SaveShareCertificateDisclaimerMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  disclaimerText: Scalars['CleanString']['input'];\n  disclaimer?: InputMaybe<Scalars['ShareCertificateDisclaimerCakeType']['input']>;\n  sharetypeDefault?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n}>;\n\n\nexport type SaveShareCertificateDisclaimerMutation = { __typename?: 'Mutation', saveShareCertificateDisclaimer?: string | null };\n\nexport type DeleteShareCertificateDisclaimerMutationVariables = Exact<{\n  disclaimer: Scalars['ShareCertificateDisclaimerCakeType']['input'];\n}>;\n\n\nexport type DeleteShareCertificateDisclaimerMutation = { __typename?: 'Mutation', deleteShareCertificateDisclaimer?: boolean | null };\n\nexport type ShareCertificateDisclaimerQueryVariables = Exact<{\n  disclaimer: Scalars['ShareCertificateDisclaimerCakeType']['input'];\n}>;\n\n\nexport type ShareCertificateDisclaimerQuery = { __typename?: 'Query', shareCertificateDisclaimer?: { __typename?: 'ShareCertificateDisclaimerType', id: string, name: string, disclaimerText: string, sharetypeDefault?: { __typename?: 'Sharetype', id: string } | null } | null };\n\nexport type ShareCertificateDisclaimersListQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type ShareCertificateDisclaimersListQuery = { __typename?: 'Query', shareCertificateDisclaimersList?: Array<{ __typename?: 'ShareCertificateDisclaimerType', id: string, name: string, disclaimerText: string, sharetypeDefault?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } | null> | null, sharetypes?: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string } | null> | null };\n\nexport type GetCopilotOnboardingDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  userId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetCopilotOnboardingDataQuery = { __typename?: 'Query', userInviteSender?: string | null, organisationUserRolePosition?: { __typename?: 'OrganisationUserRolePositionType', role?: string | null, position?: string | null } | null, organisation?: { __typename?: 'Organisation', name: string, logo: string } | null };\n\nexport type RevertCancelSubscriptionMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type RevertCancelSubscriptionMutation = { __typename?: 'Mutation', revertCancelSubscription?: boolean | null };\n\nexport type PaginatedShareholdersQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['Int']['input'];\n  itemsPerPage: Scalars['Int']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n  shareholderIdsToExclude?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>>;\n}>;\n\n\nexport type PaginatedShareholdersQuery = { __typename?: 'Query', paginatedShareholders?: { __typename?: 'PaginatedShareholderType', notSignedUpCount?: number | null, count: number, currentPage: number, pageData?: Array<{ __typename?: 'Shareholder', hasLoggedIn?: boolean | null, consideredInvited?: boolean | null, id: string, displayName?: string | null, avatar?: string | null, secondaryName?: string | null, trustName?: string | null, computedType?: string | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null } | null, trust?: { __typename?: 'TrustType', id: string } | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, address?: { __typename?: 'InternationalAddressField', country?: string | null, administrativeArea1?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null } | null } | null> | null, employeeData?: { __typename?: 'EmployeeDataType', role: SeEmployeeDataRoleChoices, level: SeEmployeeDataLevelChoices } | null } | null> | null } | null };\n\nexport type ShareholderNamesQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type ShareholderNamesQuery = { __typename?: 'Query', shareholderNames?: Array<Array<string | null> | null> | null };\n\nexport type ShareholdersCountQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type ShareholdersCountQuery = { __typename?: 'Query', shareholdersCount?: number | null };\n\nexport type ShareholdersWithShareholdingsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page: Scalars['Int']['input'];\n  itemsPerPage: Scalars['Int']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type ShareholdersWithShareholdingsQuery = { __typename?: 'Query', paginatedShareholders?: { __typename?: 'PaginatedShareholderType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trust?: { __typename?: 'TrustType', id: string } | null, groupedShareholdings?: Array<{ __typename?: 'GroupedShareholdingType', totalShares?: number | null, totalInvested?: number | null, totalUnpaid?: number | null, sharetype: { __typename?: 'Sharetype', name: string, id: string, symbol: string } } | null> | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null } | null } | null> | null } | null> | null } | null };\n\nexport type GetShareholdersWithSharesAtDateQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetShareholdersWithSharesAtDateQuery = { __typename?: 'Query', shareholdersWithSharesAtDate?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null } | null> | null };\n\nexport type GetShareholdersPageDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type GetShareholdersPageDataQuery = { __typename?: 'Query', canEditOnboardedShareholders?: boolean | null, shareholdersList?: { __typename?: 'PaginatedShareholderListType', notSignedUpCount?: number | null, currentPage: number, count: number, pageData?: Array<{ __typename?: 'ListContextShareholderType', id?: string | null, displayName?: string | null, avatar?: string | null, email?: string | null, secondaryName?: string | null, stakeholderType?: string | null, consideredInvited?: boolean | null, hasLoggedIn?: boolean | null, isGeneratingCertificate?: boolean | null, lastCertificateId?: string | null, lastCertificateName?: string | null, isTrust?: boolean | null, totalShares?: number | null, sharetypeHoldings?: Array<{ __typename?: 'SharetypeHoldingType', id?: string | null, symbol?: string | null, name?: string | null, shares?: number | null, realShares?: number | null, investment?: number | null, totalUnpaid?: number | null, unvestedShares?: number | null } | null> | null } | null> | null } | null, organisation?: { __typename?: 'Organisation', lastCertificateNumber?: number | null, totalShares?: number | null, totalSharesUnexercised?: number | null, fundingPhase?: string | null, shareCertificateType: OrganisationsOrganisationShareCertificateTypeChoices } | null, sharetypes?: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string, authorisedShares?: number | null, totals?: { __typename?: 'SharetypeTotals', totalShares?: number | null, amountRaised?: number | null, totalDue?: number | null } | null } | null> | null, esss?: Array<{ __typename?: 'Ess', id: string } | null> | null, founderVestings?: Array<{ __typename?: 'FounderVestingOutputType', id: string } | null> | null };\n\nexport type ShareholderTransactionsQueryVariables = Exact<{\n  shareholderId: Scalars['UUID']['input'];\n}>;\n\n\nexport type ShareholderTransactionsQuery = { __typename?: 'Query', shareholderTransactions?: { __typename?: 'Shareholder', shareholdings?: Array<{ __typename?: 'ShareholdingType', transactionId?: string | null, shareholderId?: string | null, transactionDate?: string | null, transactionType?: string | null, shares?: number | null, amount?: number | null, unpaid?: number | null, shareSplitFactor?: number | null, paidInTransfer?: number | null, accumulatedShares?: number | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null } | null> | null } | null };\n\nexport type GetShareholdersToEditTransactionsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetShareholdersToEditTransactionsQuery = { __typename?: 'Query', shareholdersWithShareholdings?: { __typename?: 'PaginatedShareholderHoldingsType', pageData?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, primaryEmail?: string | null, shareholdings?: Array<{ __typename?: 'ShareholdingType', shares?: number | null, amount?: number | null, transactionDate?: string | null, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } | null> | null } | null> | null } | null, sharetypes?: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string } | null> | null };\n\nexport type GetSignerOfficeholdersQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetSignerOfficeholdersQuery = { __typename?: 'Query', officeholders?: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, avatar?: string | null, signer?: SeOfficeholderSignerChoices | null, signature?: string | null, roles: Array<{ __typename?: 'OfficeholderRoleType', role: SeOfficeholderRoleRoleChoices, name?: string | null }> } | null> | null };\n\nexport type GetCertificateDetailsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetCertificateDetailsQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', name: string, country?: string | null, logoImage?: string | null, lastCertificateNumber?: number | null, totalShares?: number | null, companyDetails?:\n      | { __typename?: 'AuCompanyDetailsField', acn?: string | null, registrationLocation?: string | null, registeredAgentName?: string | null, registeredAgentEmail?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'CaCompanyDetailsField', bn?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'EeCompanyDetailsField', brc?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'GbCompanyDetailsField', crn?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'InCompanyDetailsField', cin?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'NzCompanyDetailsField', nzbn?: string | null, registeredAgentName?: string | null, registeredAgentEmail?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'SgCompanyDetailsField', uen?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n      | { __typename?: 'UsCompanyDetailsField', stateOfRegistration: InternationalUsCompanyDetailsStateOfRegistrationChoices, ein?: string | null, registeredAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null }\n     | null } | null, officeholders?: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, avatar?: string | null, signer?: SeOfficeholderSignerChoices | null, signature?: string | null, roles: Array<{ __typename?: 'OfficeholderRoleType', role: SeOfficeholderRoleRoleChoices, name?: string | null }> } | null> | null, shareCertificateDisclaimersList?: Array<{ __typename?: 'ShareCertificateDisclaimerType', id: string, name: string, sharetypeDefault?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } | null> | null };\n\nexport type AddShareholderMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareholderDataList: Array<InputMaybe<ShareholderDataInput>> | InputMaybe<ShareholderDataInput>;\n}>;\n\n\nexport type AddShareholderMutation = { __typename?: 'Mutation', addShareholder?: Array<{ __typename?: 'Shareholder', id: string, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null } | null> | null };\n\nexport type IssueSharesMutationVariables = Exact<{\n  issueSharesInputList: Array<InputMaybe<IssueSharesInput>> | InputMaybe<IssueSharesInput>;\n}>;\n\n\nexport type IssueSharesMutation = { __typename?: 'Mutation', issueShares?: boolean | null };\n\nexport type SetupSharetypesAndShareholdersMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  sharetypes: Array<CreateOrUpdateSharetypeInput> | CreateOrUpdateSharetypeInput;\n  shareholderIssueSharesInputList: Array<InputMaybe<ShareholderIssueSharesInput>> | InputMaybe<ShareholderIssueSharesInput>;\n}>;\n\n\nexport type SetupSharetypesAndShareholdersMutation = { __typename?: 'Mutation', setupSharetypes?: Array<{ __typename?: 'Sharetype', id: string } | null> | null, addShareholderIssueShares?: Array<{ __typename?: 'Shareholder', id: string } | null> | null };\n\nexport type IssueOfferSharesMutationVariables = Exact<{\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  certificateCount: Scalars['Int']['input'];\n  issueDate?: InputMaybe<Scalars['Date']['input']>;\n}>;\n\n\nexport type IssueOfferSharesMutation = { __typename?: 'Mutation', issueOfferShares?: { __typename?: 'IssueOfferShares', certificate?: { __typename?: 'Document', id: string } | null } | null };\n\nexport type AddShareSplitMutationVariables = Exact<{\n  shareType: Scalars['SharetypeCakeType']['input'];\n  splitFactor: Scalars['CakeDecimal']['input'];\n  splitDate: Scalars['Date']['input'];\n}>;\n\n\nexport type AddShareSplitMutation = { __typename?: 'Mutation', addShareSplit?: { __typename?: 'ShareholdingTransaction', id: string } | null };\n\nexport type AddBuyBackMutationVariables = Exact<{\n  addBuyBackData: AddBuyBackInput;\n}>;\n\n\nexport type AddBuyBackMutation = { __typename?: 'Mutation', addBuyBack?: { __typename?: 'AddBuyBack', shareholdingTransaction?: { __typename?: 'ShareholdingTransaction', id: string } | null } | null };\n\nexport type UpdateShareholderMutationVariables = Exact<{\n  shareholderId: Scalars['ShareholderCakeType']['input'];\n  shareholderData: ShareholderDataInput;\n}>;\n\n\nexport type UpdateShareholderMutation = { __typename?: 'Mutation', updateShareholder?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, comments?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null } | null };\n\nexport type DeleteShareholdersMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareholderIdList?: InputMaybe<Array<InputMaybe<Scalars['ShareholderCakeType']['input']>> | InputMaybe<Scalars['ShareholderCakeType']['input']>>;\n  search?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type DeleteShareholdersMutation = { __typename?: 'Mutation', deleteShareholders?: { __typename?: 'ShareholdersDeleteAttempt', deletionCount?: number | null, existingTransactions?: Array<{ __typename?: 'ShareholderExistingTransactions', name?: string | null, reason?: string | null } | null> | null } | null };\n\nexport type TransferSharesMutationVariables = Exact<{\n  transferSharesData: TransferSharesData;\n}>;\n\n\nexport type TransferSharesMutation = { __typename?: 'Mutation', transferShares?: { __typename?: 'TransferShares', organisation?: { __typename?: 'Organisation', id: string } | null } | null };\n\nexport type GetShareSplitDetailsQueryVariables = Exact<{\n  transactionId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetShareSplitDetailsQuery = { __typename?: 'Query', getShareSplitDetails?: Array<{ __typename?: 'ShareSplitDetailType', shareholderId: string, remainder: number, shares: number, shareholderName: string } | null> | null };\n\nexport type ConvertSharesMutationVariables = Exact<{\n  shareholderId: Scalars['UUID']['input'];\n  beneficiaryId?: InputMaybe<Scalars['UUID']['input']>;\n  fromSharetypeId: Scalars['UUID']['input'];\n  toSharetypeId: Scalars['UUID']['input'];\n  numberOfShares: Scalars['PositiveInteger']['input'];\n  splitFactor: Scalars['CakeDecimal']['input'];\n  conversionDate: Scalars['Date']['input'];\n}>;\n\n\nexport type ConvertSharesMutation = { __typename?: 'Mutation', convertShares?: { __typename?: 'ConvertShares', transactionFrom?: { __typename?: 'ShareholdingTransaction', id: string } | null } | null };\n\nexport type UpdateSignerMutationVariables = Exact<{\n  officeholderId: Scalars['UUID']['input'];\n  isPrimary: Scalars['Boolean']['input'];\n  isDeleteOnly: Scalars['Boolean']['input'];\n}>;\n\n\nexport type UpdateSignerMutation = { __typename?: 'Mutation', updateSigner?: { __typename?: 'UpdateSigner', ok?: boolean | null } | null };\n\nexport type ToggleWitnessSubscriptionAgreementMutationVariables = Exact<{\n  offerId: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  requireWitness: Scalars['Boolean']['input'];\n}>;\n\n\nexport type ToggleWitnessSubscriptionAgreementMutation = { __typename?: 'Mutation', toggleWitnessSubscriptionAgreement?: boolean | null };\n\nexport type ToggleWitnessOfferNoteMutationVariables = Exact<{\n  offerId: Scalars['NotesRoundOfferCakeType']['input'];\n  requireWitness: Scalars['Boolean']['input'];\n}>;\n\n\nexport type ToggleWitnessOfferNoteMutation = { __typename?: 'Mutation', toggleWitnessOfferNote?: boolean | null };\n\nexport type InvestorNotesQueryVariables = Exact<{\n  shareholder: Scalars['ShareholderCakeType']['input'];\n}>;\n\n\nexport type InvestorNotesQuery = { __typename?: 'Query', investorNotes?: Array<{ __typename?: 'Note', id: string, resolution?: NotesNoteResolutionChoices | null, principal?: number | null, discountRate?: number | null, maturityDate?: string | null, interestRate?: number | null, issueDate: string, valuationCap?: number | null, noteType: NotesNoteTypeChoices, shareholder: { __typename?: 'Shareholder', displayName?: string | null } } | null> | null };\n\nexport type DeleteNoteMutationVariables = Exact<{\n  note: Scalars['NoteCakeType']['input'];\n}>;\n\n\nexport type DeleteNoteMutation = { __typename?: 'Mutation', deleteNote?: boolean | null };\n\nexport type GetCaptableUsersQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  search?: InputMaybe<Scalars['String']['input']>;\n  excludeByIds?: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>>;\n}>;\n\n\nexport type GetCaptableUsersQuery = { __typename?: 'Query', shareholders?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null } | null> | null, officeholders?: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, avatar?: string | null } | null> | null, cakeGroups?: Array<{ __typename?: 'CakeGroupType', id: string, name?: string | null, count?: number | null, groupType: SeCakeGroupGroupTypeChoices } | null> | null };\n\nexport type SendCaptableDocumentUploadEmailsMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type SendCaptableDocumentUploadEmailsMutation = { __typename?: 'Mutation', sendCaptableDocumentUploadEmails?: boolean | null };\n\nexport type IsCaptableSensitiveQueryVariables = Exact<{\n  sharetypeId: Scalars['SharetypeCakeType']['input'];\n  at?: InputMaybe<Scalars['Date']['input']>;\n  destructive?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type IsCaptableSensitiveQuery = { __typename?: 'Query', isCaptableSensitive?: boolean | null };\n\nexport type OrganisationQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type OrganisationQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', totalSecurities?: number | null, totalShares?: number | null, sharetypeSet: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string }> } | null };\n\nexport type GetModelerSeedDataQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  organisationIdUuid: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetModelerSeedDataQuery = { __typename?: 'Query', dashboardOwnership?: { __typename?: 'DashboardOwnership', totalShares?: number | null, valuation?: number | null, topShareholders?: Array<{ __typename?: 'ShareholderOwnership', sid?: string | null, name?: string | null, number?: number | null } | null> | null } | null, dashboardEsopAggregate?: { __typename?: 'DashboardEsopAggregate', totalOptions?: number | null, exercised?: number | null, allocated?: number | null, unallocated?: number | null } | null, shareholdersWithNoteholdings?: { __typename?: 'PaginatedShareholderHoldingsType', pageData?: Array<{ __typename?: 'Shareholder', displayName?: string | null, notes?: Array<{ __typename?: 'Note', id: string, resolution?: NotesNoteResolutionChoices | null, principal?: number | null, discountRate?: number | null, maturityDate?: string | null, interestRate?: number | null, issueDate: string, valuationCap?: number | null, noteType: NotesNoteTypeChoices } | null> | null } | null> | null } | null };\n\nexport type IsTransactionEditableQueryVariables = Exact<{\n  transactionId: Scalars['ShareholdingTransactionCakeType']['input'];\n}>;\n\n\nexport type IsTransactionEditableQuery = { __typename?: 'Query', isTransactionEditable?: boolean | null, transactionDetails?: Array<{ __typename?: 'ShareholdingTransaction', transactionDate: string, shares?: number | null, amount?: number | null, paidInTransfer?: number | null, transactionId: string, transactionType: SeShareholdingTransactionTypeChoices, shareholder?: { __typename?: 'Shareholder', id: string, displayName?: string | null, secondaryName?: string | null } | null, sharetype: { __typename?: 'Sharetype', id: string, name: string, symbol: string } } | null> | null };\n\nexport type EditTransactionMutationVariables = Exact<{\n  transactionId: Scalars['ShareholdingTransactionCakeType']['input'];\n  shares?: InputMaybe<Scalars['PositiveInteger']['input']>;\n  amount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  transactionDate?: InputMaybe<Scalars['Date']['input']>;\n}>;\n\n\nexport type EditTransactionMutation = { __typename?: 'Mutation', editTransaction?: boolean | null };\n\nexport type ShareholdersReportQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  reportDate: Scalars['Date']['input'];\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type ShareholdersReportQuery = { __typename?: 'Query', shareholdersReport?: { __typename?: 'ReportResponse', unallocatedOptions?: number | null, unallocatedShares?: number | null, unallocatedRsus?: number | null, sharetypes?: Array<{ __typename?: 'SharetypeReportEntry', id?: string | null, symbol?: string | null, name?: string | null, hasPlans?: boolean | null } | null> | null, shareholders?: Array<{ __typename?: 'ShareholderReportEntry', id?: string | null, displayName?: string | null, shares?: number | null, holdings?: Array<{ __typename?: 'ShareholderHoldingsReportEntry', sharetype?: string | null, shares?: number | null, unvestedShares?: number | null } | null> | null } | null> | null, optionholders?: Array<{ __typename?: 'VestableholderReportEntry', id?: string | null, displayName?: string | null, vestingValue?: number | null, granted?: number | null, vested?: number | null, lapsed?: number | null, exercised?: number | null } | null> | null, rsuholders?: Array<{ __typename?: 'VestableholderReportEntry', id?: string | null, displayName?: string | null, vestingValue?: number | null, granted?: number | null, vested?: number | null, lapsed?: number | null, exercised?: number | null } | null> | null } | null, organisation?: { __typename?: 'Organisation', valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null } | null };\n\nexport type GetOrganisationDataBasicQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetOrganisationDataBasicQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', name: string, logoImage?: string | null } | null };\n\nexport type EditOnboardedShareholdersMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareholderIssueSharesInputList: Array<ShareholderIssueSharesInput> | ShareholderIssueSharesInput;\n}>;\n\n\nexport type EditOnboardedShareholdersMutation = { __typename?: 'Mutation', editOnboardedShareholders?: boolean | null };\n\nexport type GetTrusteesQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type GetTrusteesQuery = { __typename?: 'Query', getTrustees?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, secondaryName?: string | null, trustName?: string | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null } | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null } | null, address?: { __typename?: 'InternationalAddressField', country?: string | null, administrativeArea1?: string | null } | null } | null> | null } | null> | null };\n\nexport type GetUserPreferenceQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['String']['input'];\n  defaultValue?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type GetUserPreferenceQuery = { __typename?: 'Query', userPreference?: boolean | null };\n\nexport type SetUserPreferenceMutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['String']['input'];\n  value: Scalars['Boolean']['input'];\n}>;\n\n\nexport type SetUserPreferenceMutation = { __typename?: 'Mutation', setUserPreference?: boolean | null };\n\nexport type GetChecklistQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetChecklistQuery = { __typename?: 'Query', getChecklist?: Array<{ __typename?: 'ChecklistItem', key?: string | null, title?: string | null, description?: string | null, completed?: boolean | null, recommended?: boolean | null, userPreference?: string | null } | null> | null };\n\nexport type GetMainMenuDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  addon: Scalars['CleanString']['input'];\n}>;\n\n\nexport type GetMainMenuDataQuery = { __typename?: 'Query', price409A?: number | null, organisation?: { __typename?: 'Organisation', hasGrantedEsopOffers?: boolean | null, hasEsopPlans?: boolean | null, hasEssPlans?: boolean | null, hasRsuPlans?: boolean | null, hasValuation?: boolean | null, uploadInProgress: boolean, showOnboarding: boolean, creationIntents: Array<string> } | null, organisationDocuments?: { __typename?: 'PaginatedDocuments', count: number } | null, actionItems?: { __typename?: 'PaginatedActionItems', count: number } | null };\n\nexport type GetNeedsOnboardingQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetNeedsOnboardingQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', showOnboarding: boolean, creationIntents: Array<string> } | null };\n\nexport type GetBeginnerMenuDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetBeginnerMenuDataQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', hasValuation?: boolean | null, uploadInProgress: boolean } | null, organisationDocuments?: { __typename?: 'PaginatedDocuments', count: number } | null, actionItems?: { __typename?: 'PaginatedActionItems', count: number } | null };\n\nexport type GetDataToCreateVestablePlanQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetDataToCreateVestablePlanQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', totalSecurities?: number | null, totalSharesUnexercised?: number | null, totalShares?: number | null, sharetypeSet: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string }> } | null };\n\nexport type GetNotSignedUpStakeholdersQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  holdingsType: HoldingsType;\n  holdingsContext?: InputMaybe<Scalars['UUID']['input']>;\n}>;\n\n\nexport type GetNotSignedUpStakeholdersQuery = { __typename?: 'Query', notSignedUpShareholders?: { __typename?: 'NotSignedUpShareholdersResultType', notSignedUpCount?: number | null, results?: Array<{ __typename?: 'NotSignedUpShareholderType', id?: string | null, name?: string | null, email?: string | null, consideredInvited?: boolean | null } | null> | null } | null };\n\nexport type GetShareholdersOverviewPageDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  trust?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n  diluted?: InputMaybe<Scalars['Boolean']['input']>;\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type GetShareholdersOverviewPageDataQuery = { __typename?: 'Query', shareholdersOverview?: { __typename?: 'PaginatedOverviewShareholderType', currentPage: number, count: number, pageData?: Array<{ __typename?: 'OverviewShareholderType', id?: string | null, displayName?: string | null, avatar?: string | null, email?: string | null, secondaryName?: string | null, stakeholderType?: string | null, consideredInvited?: boolean | null, hasLoggedIn?: boolean | null, isTrust?: boolean | null, totalVestedOptions?: number | null, totalUnvestedOptions?: number | null, totalVestedRsus?: number | null, totalUnvestedRsus?: number | null, totalSecurities?: number | null, totalShares?: number | null, totalSafeNotesInvestment?: number | null, totalConvertibleNotesInvestment?: number | null, sharetypeHoldings?: Array<{ __typename?: 'SharetypeHoldingType', id?: string | null, symbol?: string | null, name?: string | null, shares?: number | null, weight?: number | null, unvestedShares?: number | null } | null> | null } | null> | null } | null, organisation?: { __typename?: 'Organisation', totalShares?: number | null, fullyDilutedShares?: number | null, logoImage?: string | null, name: string, hasEsopPlans?: boolean | null, hasEssPlans?: boolean | null, hasRsuPlans?: boolean | null, hasSafeNotes?: boolean | null, hasConNotes?: boolean | null, hasFounderVestingPlans?: boolean | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null } | null, sharetypes?: Array<{ __typename?: 'Sharetype', id: string, symbol: string, weight?: number | null, totals?: { __typename?: 'SharetypeTotals', totalShares?: number | null } | null } | null> | null };\n\nexport type GetTotalSecuritiesBreakdownQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetTotalSecuritiesBreakdownQuery = { __typename?: 'Query', shareholdersSecuritiesBreakdown?: { __typename?: 'OverviewSecuritiesBreakdownType', totalUnallocatedShares?: number | null, totalOfferedRsus?: number | null, totalUnallocatedRsus?: number | null, totalNotesInvestment?: number | null, sharetypeHoldings?: Array<{ __typename?: 'SharetypeHoldingType', name?: string | null, shares?: number | null } | null> | null } | null };\n\nexport type GenerateUsIrsForm3921MutationVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GenerateUsIrsForm3921Mutation = { __typename?: 'Mutation', generateUsIrsForm3921?: boolean | null };\n\nexport type GetShareholdersFullDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  shareholderId: Scalars['UUID']['input'];\n  shareholder: Scalars['ShareholderCakeType']['input'];\n  isTrust: Scalars['Boolean']['input'];\n}>;\n\n\nexport type GetShareholdersFullDataQuery = { __typename?: 'Query', shareholderTransactions?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, comments?: string | null, identificationCode?: string | null, isGeneratingCertificate?: boolean | null, totalPaidInIssuance?: number | null, trust?: { __typename?: 'TrustType', id: string, name: string } | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null } | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null, lastShareCertificate?: { __typename?: 'Document', id: string, name?: string | null } | null, shareholdings?: Array<{ __typename?: 'ShareholdingType', transactionId?: string | null, shareholderId?: string | null, transactionDate?: string | null, transactionType?: string | null, shares?: number | null, amount?: number | null, accumulatedShares?: number | null, unpaid?: number | null, shareSplitFactor?: number | null, paidInTransfer?: number | null, lastComment?: string | null, attachedDocumentId?: string | null, attachedDocumentName?: string | null, sharetype?: { __typename?: 'Sharetype', id: string, symbol: string } | null, lastShareCertificate?: { __typename?: 'Document', id: string, name?: string | null } | null } | null> | null, noteholdings?: Array<{ __typename?: 'NoteTransaction', transactionDate: string, transactionId: string, transactionType: NotesNoteTransactionTypeChoices, note: { __typename?: 'Note', type: NotesNoteTypeChoices, principal?: number | null, interestRate?: number | null, discountRate?: number | null, valuationCap?: number | null }, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null } } | null> | null, optionholdings?: Array<{ __typename?: 'EsopTransaction', transactionDate: string, vestingValue?: number | null, exercisePrice?: number | null, esopName?: string | null, lastComment?: string | null, transactionId: string, transactionType: EsopEsopTransactionTypeChoices, sharetype?: { __typename?: 'Sharetype', symbol: string } | null } | null> | null, rsuholdings?: Array<{ __typename?: 'RsuTransactionOutputType', transactionDate: string, vestingValue?: number | null, planName?: string | null, lastComment?: string | null, transactionId: string, transactionType: RsuRsuTransactionTypeChoices, sharetype?: { __typename?: 'Sharetype', symbol: string } | null } | null> | null, groupedShareholdings?: Array<{ __typename?: 'GroupedShareholdingType', totalShares?: number | null, totalInvested?: number | null, totalUnpaid?: number | null, totalTransferPaid?: number | null, totalTransferReceived?: number | null, sharetype: { __typename?: 'Sharetype', id: string, symbol: string } } | null> | null, groupedNoteholdings?: Array<{ __typename?: 'GroupedNoteholdingType', totalNotes?: number | null, totalInvested?: number | null, notetype?: string | null } | null> | null, groupedOptionholdings?: Array<{ __typename?: 'GroupedOptionholdingType', granted?: number | null, vested?: number | null, exercised?: number | null, lapsed?: number | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null, esopOffer?: { __typename?: 'EsopOffer', id: string, status?: string | null, softStatus?: string | null, optionPrice?: number | null, exercisePrice?: number | null, hasTransactions?: boolean | null, vestStartDate?: string | null, emailsOn: boolean, group: { __typename?: 'EsopOfferGroup', id: string, country?: string | null, plan: { __typename?: 'Esop', name?: string | null, id: string } }, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, data?: Array<{ __typename?: 'VestingCalendarOutputEntry', vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null, x?: string | null, y?: number | null }> | null } | null, vestingEvents?: Array<{ __typename?: 'EsopVestingEventType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'EsopTransaction', id: string, transactionDate: string, vestingValue?: number | null, type: EsopEsopTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null } | null } | null> | null, groupedShareVestHoldings?: Array<{ __typename?: 'GroupedShareVestHoldingType', granted?: number | null, vested?: number | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null, essOffer?: { __typename?: 'EssOffer', id: string, status?: string | null, hasTransactions?: boolean | null, vestStartDate?: string | null, softStatus?: string | null, group: { __typename?: 'EssOfferGroup', plan: { __typename?: 'Ess', name?: string | null, id: string } }, transactionSet: Array<{ __typename?: 'EssTransaction', vestingValue?: number | null, transactionDate: string, type: EssEssTransactionTypeChoices }>, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, data?: Array<{ __typename?: 'VestingCalendarOutputEntry', vestingValue?: number | null, entryType?: string | null, transactionId?: string | null, x?: string | null, y?: number | null }> | null } | null, vestingEvents?: Array<{ __typename?: 'EssVestingEventType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'EssTransaction', id: string }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null } | null } | null> | null, groupedFounderVestingHoldings?: Array<{ __typename?: 'GroupedFounderVestHoldingType', granted?: number | null, vested?: number | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null, founderVestingOffer?: { __typename?: 'FounderVestingOfferOutputType', id: string, status?: string | null, hasTransactions?: boolean | null, vestStartDate?: string | null, softStatus?: string | null, emailsOn: boolean, group: { __typename?: 'FounderVestingOfferGroupOutputType', plan: { __typename?: 'FounderVestingOutputType', name?: string | null, id: string } }, transactionSet: Array<{ __typename?: 'FounderVestingTransactionOutputType', vestingValue?: number | null, transactionDate: string, type: FoundervestingFounderVestingTransactionTypeChoices }>, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, data?: Array<{ __typename?: 'VestingCalendarOutputEntry', vestingValue?: number | null, entryType?: string | null, transactionId?: string | null, x?: string | null, y?: number | null }> | null } | null, vestingEvents?: Array<{ __typename?: 'FounderVestingVestingEventOutputType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'FounderVestingTransactionOutputType', id: string }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null } | null } | null> | null, groupedRsuHoldings?: Array<{ __typename?: 'GroupedRsuHoldingType', granted?: number | null, vested?: number | null, exercised?: number | null, lapsed?: number | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null, rsuOffer?: { __typename?: 'RsuOfferOutputType', id: string, status?: string | null, softStatus?: string | null, hasTransactions?: boolean | null, vestStartDate?: string | null, emailsOn: boolean, group: { __typename?: 'RsuOfferGroupOutputType', id: string, country?: string | null, plan: { __typename?: 'RsuOutputType', name?: string | null, id: string } }, calendar?: { __typename?: 'OfferCalendarOutputType', vestStartDate?: string | null, data?: Array<{ __typename?: 'VestingCalendarOutputEntry', vestingValue?: number | null, lapsed?: number | null, entryType?: string | null, transactionId?: string | null, x?: string | null, y?: number | null }> | null } | null, vestingEvents?: Array<{ __typename?: 'RsuVestingEventOutputType', id: string, order: number, vestingValue: number, eventType?: string | null, transactionSet: Array<{ __typename?: 'RsuTransactionOutputType', id: string, transactionDate: string, vestingValue?: number | null, type: RsuRsuTransactionTypeChoices }>, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null } | null } | null> | null, groupedBeneficiariesShareholdings?: Array<{ __typename?: 'GroupedShareholdingInTrustType', totalShares?: number | null, totalInvested?: number | null, totalUnpaid?: number | null, beneficiary: { __typename?: 'Shareholder', id: string, displayName?: string | null, hasLoggedIn?: boolean | null, consideredInvited?: boolean | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null } | null> | null }, sharetype: { __typename?: 'Sharetype', name: string, symbol: string } } | null> | null, groupedShareholdingsInTrust?: Array<{ __typename?: 'GroupedShareholdingInTrustType', totalShares?: number | null, totalInvested?: number | null, totalUnpaid?: number | null, trustee: { __typename?: 'Shareholder', id: string, displayName?: string | null, hasLoggedIn?: boolean | null, consideredInvited?: boolean | null }, sharetype: { __typename?: 'Sharetype', name: string, symbol: string } } | null> | null, beneficiaryShareholdings?: Array<{ __typename?: 'ShareholdingType', transactionId?: string | null, shareholderId?: string | null, shareholderName?: string | null, transactionDate?: string | null, transactionType?: string | null, shares?: number | null, amount?: number | null, accumulatedShares?: number | null, unpaid?: number | null, shareSplitFactor?: number | null, paidInTransfer?: number | null, lastComment?: string | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null, lastShareCertificate?: { __typename?: 'Document', id: string, name?: string | null } | null } | null> | null } | null, shareholderDocument?: Array<{ __typename?: 'Document', id: string, name?: string | null, extension?: string | null } | null> | null, organisation?: { __typename?: 'Organisation', lastCertificateNumber?: number | null, totalSharesUnexercised?: number | null, totalShares?: number | null, shareCertificateType: OrganisationsOrganisationShareCertificateTypeChoices } | null };\n\nexport type GetPeopleQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['Int']['input'];\n  itemsPerPage: Scalars['Int']['input'];\n  filters?: InputMaybe<Array<ListFilterType> | ListFilterType>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']> | Scalars['CleanString']['input']>;\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type GetPeopleQuery = { __typename?: 'Query', getPeople?: { __typename?: 'PaginatedPeopleType', notSignedUpCount?: number | null, count: number, currentPage: number, pageData?: Array<{ __typename?: 'PersonType', id?: string | null, displayName?: string | null, primaryName?: string | null, secondaryName?: string | null, primaryEmail?: string | null, secondaryEmail?: string | null, hasLoggedIn?: boolean | null, consideredInvited?: boolean | null, avatar?: string | null, shareholderType?: string | null, identificationCode?: string | null, messagesCount?: number | null, sharedDocumentsCount?: number | null, primaryPhone?: string | null, trustName?: string | null, primaryAddress?: { __typename?: 'InternationalAddressField', line1?: string | null, line2?: string | null, line3?: string | null, locality?: string | null, postcode?: string | null, country?: string | null, administrativeArea1?: string | null } | null } | null> | null } | null, orgCountriesAndStates?: { __typename?: 'CountriesAndStatesType', countries?: Array<string | null> | null, states?: Array<string | null> | null } | null };\n\nexport type StakeholdersMergePreviewQueryVariables = Exact<{\n  obsoleteShareholder: Scalars['ShareholderCakeType']['input'];\n  prevalentShareholder: Scalars['ShareholderCakeType']['input'];\n}>;\n\n\nexport type StakeholdersMergePreviewQuery = { __typename?: 'Query', stakeholdersMergePreview?: { __typename?: 'MergeStakeholdersPreviewType', obsoleteShareholderPreview?: { __typename?: 'StakeholderAssetsPreviewType', documentCount?: number | null, messageCount?: number | null, sharetypeHoldings?: Array<{ __typename?: 'SharetypeHoldingType', id?: string | null, symbol?: string | null, name?: string | null, shares?: number | null } | null> | null, vestableHoldings?: Array<{ __typename?: 'StakeholderVestablePlanHoldingsType', planType?: string | null, granted?: number | null } | null> | null } | null, prevalentShareholderPreview?: { __typename?: 'StakeholderAssetsPreviewType', documentCount?: number | null, messageCount?: number | null, sharetypeHoldings?: Array<{ __typename?: 'SharetypeHoldingType', id?: string | null, symbol?: string | null, name?: string | null, shares?: number | null } | null> | null, vestableHoldings?: Array<{ __typename?: 'StakeholderVestablePlanHoldingsType', planType?: string | null, granted?: number | null } | null> | null } | null } | null };\n\nexport type MergeStakeholdersMutationVariables = Exact<{\n  obsoleteShareholder: Scalars['ShareholderCakeType']['input'];\n  prevalentShareholder: Scalars['ShareholderCakeType']['input'];\n}>;\n\n\nexport type MergeStakeholdersMutation = { __typename?: 'Mutation', mergeStakeholders?: boolean | null };\n\nexport type GetEquityRaiseFormDataQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetEquityRaiseFormDataQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', totalSharesUnexercised?: number | null, totalShares?: number | null, sharetypeSet: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string }> } | null };\n\nexport type GetRaisesSummaryQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type GetRaisesSummaryQuery = { __typename?: 'Query', equityRounds?: Array<{ __typename?: 'OrganisationRaise', id: string, name?: string | null, raiseGoalAmount?: number | null, endDate?: string | null, amountPaid?: number | null, amountRaised?: number | null } | null> | null, notesRounds?: Array<{ __typename?: 'NotesRoundType', id: string, name: string, roundInvestmentGoal?: number | null, amountPaid?: number | null, amountRaised?: number | null, endDate?: string | null } | null> | null };\n\nexport type GetEquityRoundQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  roundId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetEquityRoundQuery = { __typename?: 'Query', equityRounds?: Array<{ __typename?: 'OrganisationRaise', id: string, name?: string | null, raiseGoalAmount?: number | null, created: string, valuation?: number | null, existingShares?: number | null, minInvestAmount?: number | null, maxInvestAmount?: number | null, endDate?: string | null, amountPaid?: number | null, amountRaised?: number | null, companyOffered?: number | null, payment?:\n      | { __typename?: 'AuPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, bsb?: string | null, reference?: string | null, isTrustAccount?: boolean | null }\n      | { __typename?: 'FallbackPaymentDetailsType', details?: string | null }\n      | { __typename?: 'SgPaymentDetailsType', accountName?: string | null, accountNumber?: string | null, swiftCode?: string | null, bankCode?: string | null, branchCode?: string | null }\n     | null, contractTemplate?: { __typename?: 'Document', id: string, name?: string | null, status?: string | null, contractType?: string | null } | null, shareType: { __typename?: 'Sharetype', id: string, name: string }, documents?: Array<{ __typename?: 'Document', id: string, created: string, name?: string | null, file?: string | null, extension?: string | null } | null> | null } | null> | null, officeholders?: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, avatar?: string | null, signer?: SeOfficeholderSignerChoices | null, roles: Array<{ __typename?: 'OfficeholderRoleType', role: SeOfficeholderRoleRoleChoices, name?: string | null }> } | null> | null };\n\nexport type RaiseOffersQueryVariables = Exact<{\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n  offer?: InputMaybe<Scalars['UUID']['input']>;\n}>;\n\n\nexport type RaiseOffersQuery = { __typename?: 'Query', raiseOffers?: { __typename?: 'PaginatedEquityRoundOffersType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'OrganisationRaiseOffer', id: string, modified: string, amount?: number | null, owing?: number | null, reminderSentDate?: string | null, status: SeOrganisationRaiseOfferStatusChoices, expectedShares?: number | null, requireWitness: boolean, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, secondaryName?: string | null, avatar?: string | null, inviteLink?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, jointIndex: number, companyData?: { __typename?: 'CompanyDataType', signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null } | null> | null } | null } | null> | null }, certificate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null } | null, contract?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null, extra?: string | null } | null> | null } | null, organisationRaise: { __typename?: 'OrganisationRaise', id: string } } | null> | null } | null, organisation?: { __typename?: 'Organisation', lastCertificateNumber?: number | null } | null };\n\nexport type CreateEquityRoundMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  raiseGoalAmount: Scalars['CakeDecimal']['input'];\n  existingShares: Scalars['PositiveIntegerOrZero']['input'];\n  valuation: Scalars['ValuationCakeType']['input'];\n  shareType: Scalars['SharetypeCakeType']['input'];\n  endDate: Scalars['Date']['input'];\n  payment?: InputMaybe<Scalars['JSONString']['input']>;\n}>;\n\n\nexport type CreateEquityRoundMutation = { __typename?: 'Mutation', createEquityRound?: { __typename?: 'CreateEquityRound', organisationRaise?: { __typename?: 'OrganisationRaise', id: string } | null } | null };\n\nexport type EditEquityRoundMutationVariables = Exact<{\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n  name?: InputMaybe<Scalars['CleanString']['input']>;\n  endDate?: InputMaybe<Scalars['Date']['input']>;\n  raiseGoalAmount?: InputMaybe<Scalars['CakeDecimal']['input']>;\n  existingShares?: InputMaybe<Scalars['PositiveIntegerOrZero']['input']>;\n  shareType?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n}>;\n\n\nexport type EditEquityRoundMutation = { __typename?: 'Mutation', editEquityRound?: { __typename?: 'EditEquityRound', ok?: boolean | null } | null };\n\nexport type UpdateEquityRoundBankDetailsAuMutationVariables = Exact<{\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n  accountName?: InputMaybe<Scalars['String']['input']>;\n  paymentAccount?: InputMaybe<Scalars['String']['input']>;\n  paymentBsb?: InputMaybe<Scalars['String']['input']>;\n  paymentReference?: InputMaybe<Scalars['String']['input']>;\n  isTrustAccount?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type UpdateEquityRoundBankDetailsAuMutation = { __typename?: 'Mutation', updateEquityRoundBankDetailsAu?: { __typename?: 'UpdateEquityRoundBankDetailsAu', ok?: boolean | null } | null };\n\nexport type UpdateEquityRoundBankDetailsSgMutationVariables = Exact<{\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n  accountName?: InputMaybe<Scalars['String']['input']>;\n  accountNumber?: InputMaybe<Scalars['String']['input']>;\n  swiftCode?: InputMaybe<Scalars['String']['input']>;\n  bankCode?: InputMaybe<Scalars['String']['input']>;\n  branchCode?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type UpdateEquityRoundBankDetailsSgMutation = { __typename?: 'Mutation', updateEquityRoundBankDetailsSg?: { __typename?: 'UpdateEquityRoundBankDetailsSg', ok?: boolean | null } | null };\n\nexport type UpdateEquityRoundBankDetailsFallbackMutationVariables = Exact<{\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n  details?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type UpdateEquityRoundBankDetailsFallbackMutation = { __typename?: 'Mutation', updateEquityRoundBankDetailsFallback?: { __typename?: 'UpdateEquityRoundBankDetailsFallback', ok?: boolean | null } | null };\n\nexport type DeleteEquityRoundMutationVariables = Exact<{\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n}>;\n\n\nexport type DeleteEquityRoundMutation = { __typename?: 'Mutation', deleteEquityRound?: { __typename?: 'DeleteEquityRound', ok?: boolean | null } | null };\n\nexport type AddEquityRoundOfferMutationVariables = Exact<{\n  round: Scalars['OrganisationRaiseCakeType']['input'];\n  shareholder: Scalars['ShareholderCakeType']['input'];\n  amount: Scalars['CakeDecimal']['input'];\n}>;\n\n\nexport type AddEquityRoundOfferMutation = { __typename?: 'Mutation', addEquityRoundOffer?: { __typename?: 'AddEquityRoundOffer', organisationRaiseOffer?: { __typename?: 'OrganisationRaiseOffer', id: string } | null } | null };\n\nexport type DeleteEquityRoundOfferMutationVariables = Exact<{\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n}>;\n\n\nexport type DeleteEquityRoundOfferMutation = { __typename?: 'Mutation', deleteEquityRoundOffer?: { __typename?: 'DeleteEquityRoundOffer', ok?: boolean | null } | null };\n\nexport type UpdateEquityOfferPaymentStatusMutationVariables = Exact<{\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  paid: Scalars['CakeDecimal']['input'];\n}>;\n\n\nexport type UpdateEquityOfferPaymentStatusMutation = { __typename?: 'Mutation', updateEquityOfferPaymentStatus?: { __typename?: 'UpdateEquityOfferPaymentStatus', ok?: boolean | null } | null };\n\nexport type InviteEquityOfferMutationVariables = Exact<{\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  sendInvitationEmail: Scalars['Boolean']['input'];\n}>;\n\n\nexport type InviteEquityOfferMutation = { __typename?: 'Mutation', inviteEquityOffer?: { __typename?: 'InviteEquityOffer', ok?: boolean | null } | null };\n\nexport type SettleEquityOfferOfflineMutationVariables = Exact<{\n  offer: Scalars['OrganisationRaiseOfferCakeType']['input'];\n  amount: Scalars['CakeDecimal']['input'];\n  contract?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n}>;\n\n\nexport type SettleEquityOfferOfflineMutation = { __typename?: 'Mutation', settleEquityOfferOffline?: { __typename?: 'SettleEquityOfferOffline', ok?: boolean | null } | null };\n\nexport type SignSubscriptionAgreementOfficeholderMutationVariables = Exact<{\n  raiseOfferId: Scalars['UUID']['input'];\n}>;\n\n\nexport type SignSubscriptionAgreementOfficeholderMutation = { __typename?: 'Mutation', signSubscriptionAgreementOfficeholder?: { __typename?: 'SignSubscriptionAgreementOfficeholder', urlList?: Array<string | null> | null, signatureRequestId?: string | null, expectedCallbackUrl?: string | null } | null };\n\nexport type GetTeamDataToRequestExerciseQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetTeamDataToRequestExerciseQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', usersWithAggregatedRoles?: Array<{ __typename?: 'UserWithAggregatedRoles', role?: string | null, position?: string | null, user?: { __typename?: 'UserType', id: string, isLoggedInUser?: boolean | null, email: string, name?: string | null, picture: string } | null } | null> | null, license?: { __typename?: 'LicenseInfoType', billingEmail?: string | null, billingMobile?: string | null } | null } | null };\n\nexport type SetupExerciseRequestSettingsMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  approvers: Array<Scalars['UserCakeType']['input']> | Scalars['UserCakeType']['input'];\n  paymentDetails: ExerciseRequestPaymentDetailsInputType;\n}>;\n\n\nexport type SetupExerciseRequestSettingsMutation = { __typename?: 'Mutation', setupExerciseRequestSettings?: string | null };\n\nexport type EditExerciseRequestSettingsMutationVariables = Exact<{\n  exerciseRequestSettingsId: Scalars['OptionExerciseRequestSettingsCakeType']['input'];\n  canRequestExercise?: InputMaybe<Scalars['Boolean']['input']>;\n  approvers?: InputMaybe<Array<Scalars['UserCakeType']['input']> | Scalars['UserCakeType']['input']>;\n  paymentDetails?: InputMaybe<ExerciseRequestPaymentDetailsInputType>;\n}>;\n\n\nexport type EditExerciseRequestSettingsMutation = { __typename?: 'Mutation', editExerciseRequestSettings?: boolean | null };\n\nexport type ExerciseRequestSettingsQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type ExerciseRequestSettingsQuery = { __typename?: 'Query', exerciseRequestSettings?: { __typename?: 'OptionExerciseRequestSettingsType', id: string, canRequestExercise: boolean, approvers?: Array<{ __typename?: 'UserType', id: string, name?: string | null, email: string, picture: string } | null> | null, paymentDetails?: { __typename?: 'PaymentDetailsOutputType', accountName?: string | null, accountNumber?: string | null, routingNumber?: string | null, additionalInstructions?: string | null } | null, exerciseNoticeTemplate: { __typename?: 'Document', id: string, name?: string | null } } | null };\n\nexport type HasExerciseRequestSettingsQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type HasExerciseRequestSettingsQuery = { __typename?: 'Query', exerciseRequestSettings?: { __typename?: 'OptionExerciseRequestSettingsType', id: string } | null };\n\nexport type ExerciseRequestsQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type ExerciseRequestsQuery = { __typename?: 'Query', exerciseRequests?: { __typename?: 'PaginatedOptionExerciseRequestType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'OptionExerciseRequestType', id: string, created: string, status: EsopOptionExerciseRequestStatusChoices, vestingValue: number, taxWithholding?: number | null, recipientReference?: string | null, shareCertificateId?: string | null, exerciseTransaction?: { __typename?: 'EsopTransaction', id: string, transactionDate: string, shareTransaction?: { __typename?: 'ShareholdingTransaction', id: string, shares?: number | null, unpaid?: number | null } | null } | null, offer?: { __typename?: 'EsopOffer', id: string, exercisePrice?: number | null, currency?: string | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', email?: string | null } | null> | null }, plan?: { __typename?: 'Esop', name?: string | null } | null, group: { __typename?: 'EsopOfferGroup', sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } } | null, exerciseNotice?: { __typename?: 'Document', id: string } | null } | null> | null } | null, organisation?: { __typename?: 'Organisation', shareCertificateType: OrganisationsOrganisationShareCertificateTypeChoices, lastCertificateNumber?: number | null } | null };\n\nexport type ApproveExerciseRequestMutationVariables = Exact<{\n  exerciseRequestId: Scalars['OptionExerciseRequestCakeType']['input'];\n  trusteeId?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n}>;\n\n\nexport type ApproveExerciseRequestMutation = { __typename?: 'Mutation', approveExerciseRequest?: boolean | null };\n\nexport type RejectExerciseRequestMutationVariables = Exact<{\n  exerciseRequestId: Scalars['OptionExerciseRequestCakeType']['input'];\n}>;\n\n\nexport type RejectExerciseRequestMutation = { __typename?: 'Mutation', rejectExerciseRequest?: boolean | null };\n\nexport type ConfirmExercisePaymentAndIssueSharesMutationVariables = Exact<{\n  exerciseRequestId: Scalars['OptionExerciseRequestCakeType']['input'];\n}>;\n\n\nexport type ConfirmExercisePaymentAndIssueSharesMutation = { __typename?: 'Mutation', confirmExercisePaymentAndIssueShares?: { __typename?: 'ConfirmExercisePaymentAndIssueShares', exerciseTransaction?: { __typename?: 'ExerciseTransactionDataType', transactionId?: string | null, transactionDate?: string | null, shares?: number | null, unpaid?: number | null, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } | null } | null };\n\nexport type GetDataToRequestExerciseSettleOffineQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  exerciseRequestId: Scalars['OptionExerciseRequestCakeType']['input'];\n}>;\n\n\nexport type GetDataToRequestExerciseSettleOffineQuery = { __typename?: 'Query', exerciseRequest?: { __typename?: 'OptionExerciseRequestType', id: string, vestingValue: number, taxWithholding?: number | null, offer?: { __typename?: 'EsopOffer', id: string, exercisePrice?: number | null, currency?: string | null } | null } | null, getTrustees?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null } | null> | null };\n\nexport type GetTrusteesToRequestExerciseQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n}>;\n\n\nexport type GetTrusteesToRequestExerciseQuery = { __typename?: 'Query', getTrustees?: Array<{ __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, employeeData?: { __typename?: 'EmployeeDataType', role: SeEmployeeDataRoleChoices, level: SeEmployeeDataLevelChoices } | null } | null> | null };\n\nexport type SettleExerciseRequestOfflineMutationVariables = Exact<{\n  exerciseRequestId: Scalars['OptionExerciseRequestCakeType']['input'];\n  exerciseDate: Scalars['Date']['input'];\n  exerciseNoticeId?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  trustee?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n}>;\n\n\nexport type SettleExerciseRequestOfflineMutation = { __typename?: 'Mutation', settleExerciseRequestOffline?: { __typename?: 'SettleExerciseRequestOffline', exerciseTransaction?: { __typename?: 'ExerciseTransactionDataType', transactionId?: string | null, transactionDate?: string | null, shares?: number | null, unpaid?: number | null, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } | null } | null };\n\nexport type GetPlanToEditRsuQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  planId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetPlanToEditRsuQuery = { __typename?: 'Query', plan?: Array<{ __typename?: 'RsuOutputType', id: string, name?: string | null, vestingValue?: number | null, requireWitness: boolean, totalVested?: number | null, totalExercised?: number | null, totalLapsed?: number | null, totalGranted?: number | null, totalOffered?: number | null, group?: Array<{ __typename?: 'RsuOfferGroupOutputType', id: string, country?: string | null, isEditable?: boolean | null, requireBoardApproval: boolean, totalOffered?: number | null, totalGranted?: number | null, totalVested?: number | null, totalLapsed?: number | null, totalExercised?: number | null, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } | null> | null } | null> | null, sharetypes?: Array<{ __typename?: 'Sharetype', id: string, name: string, symbol: string } | null> | null };\n\nexport type EditRsuMutationVariables = Exact<{\n  plan: Scalars['RsuCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  vestingValue: Scalars['PositiveInteger']['input'];\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type EditRsuMutation = { __typename?: 'Mutation', editRsu?: boolean | null };\n\nexport type EditGroupAndRsuMutationVariables = Exact<{\n  plan: Scalars['RsuCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  vestingValue: Scalars['PositiveInteger']['input'];\n  group: Scalars['RsuOfferGroupCakeType']['input'];\n  sharetype?: InputMaybe<Scalars['SharetypeCakeType']['input']>;\n  allowNomineeTrust?: InputMaybe<Scalars['Boolean']['input']>;\n  requireBoardApproval?: InputMaybe<Scalars['Boolean']['input']>;\n  enforceDisclosurePeriod?: InputMaybe<Scalars['Boolean']['input']>;\n  requireWitness?: InputMaybe<Scalars['Boolean']['input']>;\n}>;\n\n\nexport type EditGroupAndRsuMutation = { __typename?: 'Mutation', editRsu?: boolean | null, editGroupRsu?: boolean | null };\n\nexport type DeleteRsuMutationVariables = Exact<{\n  plan: Scalars['RsuCakeType']['input'];\n}>;\n\n\nexport type DeleteRsuMutation = { __typename?: 'Mutation', deleteRsu?: boolean | null };\n\nexport type GetPlansRsuQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetPlansRsuQuery = { __typename?: 'Query', plans?: Array<{ __typename?: 'RsuOutputType', id: string, name?: string | null, vestingValue?: number | null, totalExercised?: number | null, totalVested?: number | null, totalLapsed?: number | null, totalOffered?: number | null, group?: Array<{ __typename?: 'RsuOfferGroupOutputType', country?: string | null } | null> | null } | null> | null, organisation?: { __typename?: 'Organisation', fullyDilutedShares?: number | null } | null };\n\nexport type GetPlanNamesRsuQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetPlanNamesRsuQuery = { __typename?: 'Query', rsus?: Array<{ __typename?: 'RsuOutputType', id: string, name?: string | null } | null> | null };\n\nexport type GetPlanRsuQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  planId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetPlanRsuQuery = { __typename?: 'Query', plan?: Array<{ __typename?: 'RsuOutputType', id: string, name?: string | null, vestingValue?: number | null, commentCount?: number | null, requireWitness: boolean, totalVested?: number | null, totalExercised?: number | null, totalLapsed?: number | null, totalGranted?: number | null, totalOffered?: number | null, organisation: { __typename?: 'Organisation', id: string, created: string, fullyDilutedShares?: number | null, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null }, documents?: Array<{ __typename?: 'Document', id: string, created: string, name?: string | null, file?: string | null, extension?: string | null } | null> | null, group?: Array<{ __typename?: 'RsuOfferGroupOutputType', id: string, country?: string | null, totalOffered?: number | null, totalGranted?: number | null, totalVested?: number | null, totalLapsed?: number | null, totalExercised?: number | null, offerCount?: number | null, offerAcceptedCount?: number | null, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null, defaultPlanRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null, defaultOfferLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null, planRulesTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices }>, offerLetterTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices }> } | null> | null } | null> | null };\n\nexport type GetPlanGroupRsuQueryVariables = Exact<{\n  groupId: Scalars['RsuOfferGroupCakeType']['input'];\n}>;\n\n\nexport type GetPlanGroupRsuQuery = { __typename?: 'Query', group?: { __typename?: 'RsuOfferGroupOutputType', id: string, country?: string | null, totalGranted?: number | null, totalVested?: number | null, totalLapsed?: number | null, totalExercised?: number | null, totalOffered?: number | null, offerCount?: number | null, offerAcceptedCount?: number | null, allowNomineeTrust: boolean, disclosurePeriodDays: number, isEditable?: boolean | null, offerLetterTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, modified: string }>, planRulesTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null, modified: string }>, plan: { __typename?: 'RsuOutputType', id: string, name?: string | null }, sharetype?: { __typename?: 'Sharetype', id: string, name: string, symbol: string } | null } | null };\n\nexport type GetPlanOffersRsuQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  filterId: Scalars['UUID']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  filters?: InputMaybe<Array<ListFilterType> | ListFilterType>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']> | Scalars['CleanString']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type GetPlanOffersRsuQuery = { __typename?: 'Query', offers?: { __typename?: 'PaginatedRsuOffer', count: number, currentPage: number, notSignedUpCount?: number | null, shareholderCount?: number | null, plan?: { __typename?: 'RsuOutputType', id: string, vestingValue?: number | null, totalOffered?: number | null, totalLapsed?: number | null, organisation: { __typename?: 'Organisation', fullyDilutedShares?: number | null } } | null, pageData?: Array<{ __typename?: 'ListContextRsuOfferType', id?: string | null, modified?: string | null, groupId?: string | null, planId?: string | null, offerLetterId?: string | null, dateGranted?: string | null, vestStartDate?: string | null, emailsOn?: boolean | null, requireWitness?: boolean | null, shareholderId?: string | null, shareholderDisplayName?: string | null, shareholderSecondaryName?: string | null, shareholderAvatar?: string | null, shareholderHasLoggedIn?: boolean | null, shareholderConsideredInvited?: boolean | null, shEmail?: string | null, status?: string | null, softStatus?: string | null, country?: string | null, vestingValue?: number | null, availableToLapse?: number | null, availableToExercise?: number | null, availableToVest?: number | null, vested?: number | null, granted?: number | null, lapsed?: number | null, exercised?: number | null, conversionLockEventId?: string | null, conversionLockEventDescription?: string | null, conversionLockEventDate?: string | null, hasOngoingPauseEvents?: boolean | null, hasScheduledPauseEvents?: boolean | null, stakeholderType?: string | null, isTrust?: boolean | null } | null> | null } | null };\n\nexport type OffersVestingEventsRsuQueryVariables = Exact<{\n  offerIds: Array<Scalars['UUID']['input']> | Scalars['UUID']['input'];\n}>;\n\n\nexport type OffersVestingEventsRsuQuery = { __typename?: 'Query', offersVestingEvents?: Array<{ __typename?: 'RsuVestingEventOutputType', id: string, offerId?: string | null, order: number, vestingValue: number, eventType?: string | null, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null };\n\nexport type GetPlanOffersToCompleteRsuQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  offerIds: Array<InputMaybe<Scalars['UUID']['input']>> | InputMaybe<Scalars['UUID']['input']>;\n}>;\n\n\nexport type GetPlanOffersToCompleteRsuQuery = { __typename?: 'Query', offers?: Array<{ __typename?: 'RsuOfferOutputType', id: string, vestStartDate?: string | null, country?: string | null, status?: string | null, shareholderDisplayName?: string | null, shareholder?: { __typename?: 'Shareholder', id: string, secondaryName?: string | null, avatar?: string | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null } | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, jointIndex: number, companyData?: { __typename?: 'CompanyDataType', signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null } | null> | null } | null } | null> | null } | null, offerLetterTemplate?: { __typename?: 'Document', id: string } | null, group: { __typename?: 'RsuOfferGroupOutputType', id: string, country?: string | null, offerLetterTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, status?: string | null, contractType?: string | null, modified: string }>, planRulesTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, contractType?: string | null, modified: string, extension?: string | null }>, defaultPlanRulesTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null, defaultOfferLetterTemplate?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null } } | null> | null };\n\nexport type GetPlanOfferRsuQueryVariables = Exact<{\n  offerId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetPlanOfferRsuQuery = { __typename?: 'Query', offer?: { __typename?: 'RsuOfferOutputType', id: string, created: string, modified: string, plan?: { __typename?: 'RsuOutputType', id: string, name?: string | null, vestingValue?: number | null, totalOffered?: number | null, totalLapsed?: number | null, documents?: Array<{ __typename?: 'Document', id: string, name?: string | null, extension?: string | null, created: string, type: DocumentsDocumentTypeChoices } | null> | null, organisation: { __typename?: 'Organisation', id: string, name: string, country?: string | null, currency: OrganisationsOrganisationCurrencyChoices, totalShares?: number | null, created: string, totalSharesUnexercised?: number | null, fullyDilutedShares?: number | null, valuationVisibleToOptionholders?: boolean | null, logoImage?: string | null, valuationAt?: { __typename?: 'ValuationType', valuation?: number | null } | null }, group?: Array<{ __typename?: 'RsuOfferGroupOutputType', id: string, country?: string | null, sharetype?: { __typename?: 'Sharetype', symbol: string, voting: boolean, dividend: boolean } | null, offerLetterTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, modified: string }>, planRulesTemplate: Array<{ __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, status?: string | null, type: DocumentsDocumentTypeChoices, extension?: string | null, modified: string }> } | null> | null } | null, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, inviteLink?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, trustAbn?: string | null, heldInTrust?: boolean | null, trustName?: string | null, inviteLink?: string | null, computedType?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, phone?: string | null, jointIndex: number, address?: { __typename?: 'InternationalAddressField', line2?: string | null, line1?: string | null, locality?: string | null, administrativeArea1?: string | null, postcode?: string | null, country?: string | null } | null, companyData?: { __typename?: 'CompanyDataType', contactPerson?: string | null, identifierType?: IdentifierTypeOutputField | null, identifierNumber?: string | null, signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null, role?: CompanyRoleOutputField | null } | null> | null } | null } | null> | null } | null } } | null };\n\nexport type RefreshScanbotStatusMutationVariables = Exact<{\n  scanbotDocument: Scalars['ScanbotDocumentCakeType']['input'];\n}>;\n\n\nexport type RefreshScanbotStatusMutation = { __typename?: 'Mutation', refreshScanbotStatus?: boolean | null };\n\nexport type DeleteScanbotDocumentMutationVariables = Exact<{\n  scanbotDocument: Scalars['ScanbotDocumentCakeType']['input'];\n}>;\n\n\nexport type DeleteScanbotDocumentMutation = { __typename?: 'Mutation', deleteScanbotDocument?: boolean | null };\n\nexport type UploadEditableDocumentMutationVariables = Exact<{\n  scanbotDocument: Scalars['ScanbotDocumentCakeType']['input'];\n  editableDocument: Scalars['DocumentCakeType']['input'];\n}>;\n\n\nexport type UploadEditableDocumentMutation = { __typename?: 'Mutation', uploadEditableDocument?: boolean | null };\n\nexport type ScanbotDocumentQueryVariables = Exact<{\n  scanbotDocument: Scalars['ScanbotDocumentCakeType']['input'];\n}>;\n\n\nexport type ScanbotDocumentQuery = { __typename?: 'Query', scanbotDocument?: { __typename?: 'ScanbotDocumentType', id: string, created: string, status: DocumentsScanbotDocumentStatusChoices, result?: JSON | null, document: { __typename?: 'Document', name?: string | null }, editableDocument?: { __typename?: 'Document', id: string, name?: string | null } | null } | null };\n\nexport type ScanbotDocumentsQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n}>;\n\n\nexport type ScanbotDocumentsQuery = { __typename?: 'Query', scanbotDocuments?: Array<{ __typename?: 'ScanbotDocumentType', id: string, created: string, status: DocumentsScanbotDocumentStatusChoices, result?: JSON | null, document: { __typename?: 'Document', name?: string | null }, editableDocument?: { __typename?: 'Document', id: string, name?: string | null } | null } | null> | null };\n\nexport type CreateShareTransferOfferMutationVariables = Exact<{\n  shareTransferRound: Scalars['ShareTransferRoundCakeType']['input'];\n  fromShareholder: Scalars['ShareholderCakeType']['input'];\n  toShareholder: Scalars['ShareholderCakeType']['input'];\n  sharetype: Scalars['SharetypeCakeType']['input'];\n  shares: Scalars['PositiveInteger']['input'];\n  amount: Scalars['CakeDecimal']['input'];\n}>;\n\n\nexport type CreateShareTransferOfferMutation = { __typename?: 'Mutation', createShareTransferOffer?: { __typename?: 'CreateShareTransferOffer', transferOffer?: { __typename?: 'ShareTransferOfferType', id: string } | null } | null };\n\nexport type EditShareTransferOfferMutationVariables = Exact<{\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n  fromShareholder: Scalars['ShareholderCakeType']['input'];\n  toShareholder: Scalars['ShareholderCakeType']['input'];\n  sharetype: Scalars['SharetypeCakeType']['input'];\n  shares: Scalars['PositiveInteger']['input'];\n  amount: Scalars['CakeDecimal']['input'];\n}>;\n\n\nexport type EditShareTransferOfferMutation = { __typename?: 'Mutation', editShareTransferOffer?: { __typename?: 'EditShareTransferOffer', transferOffer?: { __typename?: 'ShareTransferOfferType', id: string } | null } | null };\n\nexport type DeleteShareTransferOfferMutationVariables = Exact<{\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n}>;\n\n\nexport type DeleteShareTransferOfferMutation = { __typename?: 'Mutation', deleteShareTransferOffer?: { __typename?: 'DeleteShareTransferOffer', ok?: boolean | null } | null };\n\nexport type SettleShareTransferOfferOfflineMutationVariables = Exact<{\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n  contract?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n}>;\n\n\nexport type SettleShareTransferOfferOfflineMutation = { __typename?: 'Mutation', settleShareTransferOfferOffline?: { __typename?: 'SettleShareTransferOfferOffline', ok?: boolean | null } | null };\n\nexport type InviteShareTransferOfferMutationVariables = Exact<{\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n  sendInvitationEmail: Scalars['Boolean']['input'];\n}>;\n\n\nexport type InviteShareTransferOfferMutation = { __typename?: 'Mutation', inviteShareTransferOffer?: { __typename?: 'InviteShareTransferOffer', ok?: boolean | null } | null };\n\nexport type UpdateShareTransferOfferPaymentStatusMutationVariables = Exact<{\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n  paid: Scalars['CakeDecimal']['input'];\n}>;\n\n\nexport type UpdateShareTransferOfferPaymentStatusMutation = { __typename?: 'Mutation', updateShareTransferOfferPaymentStatus?: { __typename?: 'UpdateShareTransferOfferPaymentStatus', ok?: boolean | null } | null };\n\nexport type CompleteShareTransferOfferMutationVariables = Exact<{\n  transferOffer: Scalars['ShareTransferOfferCakeType']['input'];\n  transferDate: Scalars['Date']['input'];\n  certificateCount: Scalars['PositiveInteger']['input'];\n}>;\n\n\nexport type CompleteShareTransferOfferMutation = { __typename?: 'Mutation', completeShareTransferOffer?: { __typename?: 'CompleteShareTransferOffer', ok?: boolean | null } | null };\n\nexport type GetShareTransferOffersQueryVariables = Exact<{\n  transferRound: Scalars['ShareTransferRoundCakeType']['input'];\n}>;\n\n\nexport type GetShareTransferOffersQuery = { __typename?: 'Query', shareTransferOffers?: { __typename?: 'PaginatedShareTransferOfferType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'ShareTransferOfferType', id: string, shares: number, amount?: number | null, status: TransfersShareTransferOfferStatusChoices, fromShareholderConfirmed?: boolean | null, toShareholderConfirmed?: boolean | null, fromShareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, secondaryName?: string | null, avatar?: string | null, inviteLink?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, jointIndex: number, companyData?: { __typename?: 'CompanyDataType', signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null } | null> | null } | null } | null> | null }, toShareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, secondaryName?: string | null, avatar?: string | null, inviteLink?: string | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, email?: string | null, jointIndex: number, companyData?: { __typename?: 'CompanyDataType', signers?: Array<{ __typename?: 'CompanySignerInfoType', name?: string | null, email?: string | null } | null> | null } | null } | null> | null }, sharetype: { __typename?: 'Sharetype', id: string, name: string, symbol: string }, shareTransferAgreementContract?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null, signatures?: Array<{ __typename?: 'Signature', name?: string | null, email?: string | null, status?: string | null, extra?: string | null } | null> | null } | null, offlineContract?: { __typename?: 'Document', id: string, name?: string | null, contractType?: string | null } | null, shareTransferRound: { __typename?: 'ShareTransferRoundType', id: string, shareTransferAgreementTemplate?: { __typename?: 'Document', id: string, name?: string | null, status?: string | null, contractType?: string | null } | null, organisation: { __typename?: 'Organisation', lastCertificateNumber?: number | null } } } | null> | null } | null };\n\nexport type CreateShareTransferRoundMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n}>;\n\n\nexport type CreateShareTransferRoundMutation = { __typename?: 'Mutation', createShareTransferRound?: { __typename?: 'CreateShareTransferRound', transferRound?: { __typename?: 'ShareTransferRoundType', id: string } | null } | null };\n\nexport type EditShareTransferRoundMutationVariables = Exact<{\n  transferRound: Scalars['ShareTransferRoundCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n}>;\n\n\nexport type EditShareTransferRoundMutation = { __typename?: 'Mutation', editShareTransferRound?: { __typename?: 'EditShareTransferRound', transferRound?: { __typename?: 'ShareTransferRoundType', id: string } | null } | null };\n\nexport type DeleteShareTransferRoundMutationVariables = Exact<{\n  transferRound: Scalars['ShareTransferRoundCakeType']['input'];\n}>;\n\n\nexport type DeleteShareTransferRoundMutation = { __typename?: 'Mutation', deleteShareTransferRound?: { __typename?: 'DeleteShareTransferRound', ok?: boolean | null } | null };\n\nexport type GetShareTransferRoundsAndTransfersQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type GetShareTransferRoundsAndTransfersQuery = { __typename?: 'Query', shareTransferRounds?: { __typename?: 'PaginatedShareTransferRoundType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'ShareTransferRoundType', id: string, name: string, offerCount?: number | null } | null> | null } | null, shareholdersWithShareholdings?: { __typename?: 'PaginatedShareholderHoldingsType', count: number } | null, organisationShareholdingTransactions?: { __typename?: 'PaginatedShareholdingTransaction', count: number } | null };\n\nexport type GetShareTransferRoundQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  organisation: Scalars['OrganisationCakeType']['input'];\n  filterRound?: InputMaybe<Scalars['UUID']['input']>;\n}>;\n\n\nexport type GetShareTransferRoundQuery = { __typename?: 'Query', shareTransferRounds?: { __typename?: 'PaginatedShareTransferRoundType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'ShareTransferRoundType', id: string, name: string, offerCount?: number | null, shareTransferAgreementTemplate?: { __typename?: 'Document', id: string, name?: string | null, status?: string | null, contractType?: string | null } | null, documents?: Array<{ __typename?: 'Document', id: string, created: string, name?: string | null, file?: string | null, extension?: string | null } | null> | null } | null> | null } | null, officeholders?: Array<{ __typename?: 'Officeholder', id: string, name: string, email?: string | null, avatar?: string | null, signer?: SeOfficeholderSignerChoices | null, roles: Array<{ __typename?: 'OfficeholderRoleType', role: SeOfficeholderRoleRoleChoices, name?: string | null }> } | null> | null };\n\nexport type CreateShareTransferRoundTemplateMutationVariables = Exact<{\n  transferRound: Scalars['ShareTransferRoundCakeType']['input'];\n  templateType: Scalars['CleanString']['input'];\n  name: Scalars['String']['input'];\n  baseTemplate?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n}>;\n\n\nexport type CreateShareTransferRoundTemplateMutation = { __typename?: 'Mutation', createShareTransferRoundTemplate?: { __typename?: 'CreateShareTransferRoundTemplate', ok?: boolean | null } | null };\n\nexport type ShareholderAvailableSharesToTransferQueryVariables = Exact<{\n  shareholder: Scalars['ShareholderCakeType']['input'];\n  sharetype: Scalars['SharetypeCakeType']['input'];\n  transferDate?: InputMaybe<Scalars['Date']['input']>;\n  beneficiary?: InputMaybe<Scalars['ShareholderCakeType']['input']>;\n}>;\n\n\nexport type ShareholderAvailableSharesToTransferQuery = { __typename?: 'Query', shareholderAvailableSharesToTransfer?: number | null };\n\nexport type DeleteShareTransferRoundTemplateMutationVariables = Exact<{\n  transferRound: Scalars['ShareTransferRoundCakeType']['input'];\n  templateType: Scalars['CleanString']['input'];\n}>;\n\n\nexport type DeleteShareTransferRoundTemplateMutation = { __typename?: 'Mutation', deleteShareTransferRoundTemplate?: { __typename?: 'DeleteShareTransferRoundTemplate', ok?: boolean | null } | null };\n\nexport type GetPotentialTransferSendersQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  search?: InputMaybe<Scalars['CleanString']['input']>;\n  page: Scalars['Int']['input'];\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetPotentialTransferSendersQuery = { __typename?: 'Query', getPotentialTransferSenders?: { __typename?: 'PaginatedTransferSenderType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'TransferSenderType', id?: string | null, displayName?: string | null, secondaryId?: string | null, secondaryName?: string | null } | null> | null } | null };\n\nexport type List409aValuationsQueryVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n}>;\n\n\nexport type List409aValuationsQuery = { __typename?: 'Query', list409aValuations?: { __typename?: 'PaginatedHistorical409AType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'Historical409AType', id: string, valuationDate: string, fairMarketValue: number, documentation?: { __typename?: 'Document', id: string, name?: string | null } | null } | null> | null } | null };\n\nexport type Get409aListQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n}>;\n\n\nexport type Get409aListQuery = { __typename?: 'Query', organisation?: { __typename?: 'Organisation', license?: { __typename?: 'LicenseInfoType', oneOffAddons?: Array<{ __typename?: 'OneOffAddon', status?: string | null, created?: string | null, stripeId?: string | null } | null> | null } | null } | null };\n\nexport type AddHistorical409AMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  valuationDate: Scalars['Date']['input'];\n  fairMarketValue: Scalars['CakeDecimal']['input'];\n  documentation?: InputMaybe<Scalars['DocumentCakeType']['input']>;\n  applyExercisePrice: Scalars['Boolean']['input'];\n}>;\n\n\nexport type AddHistorical409AMutation = { __typename?: 'Mutation', addHistorical409A?: string | null };\n\nexport type DeleteHistorical409AMutationVariables = Exact<{\n  historical409A: Scalars['Historical409ACakeType']['input'];\n  removeDocumentation: Scalars['Boolean']['input'];\n}>;\n\n\nexport type DeleteHistorical409AMutation = { __typename?: 'Mutation', deleteHistorical409A?: boolean | null };\n\nexport type ApplyHistorical409aStrikePriceMutationVariables = Exact<{\n  historical409a: Scalars['Historical409ACakeType']['input'];\n  esop: Scalars['EsopCakeType']['input'];\n}>;\n\n\nexport type ApplyHistorical409aStrikePriceMutation = { __typename?: 'Mutation', applyHistorical409aStrikePrice?: number | null };\n\nexport type GetVestingScheduleTemplatesQueryVariables = Exact<{\n  organisationId: Scalars['OrganisationCakeType']['input'];\n  page?: InputMaybe<Scalars['PositiveIntegerOrZero']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['PositiveInteger']['input']>;\n}>;\n\n\nexport type GetVestingScheduleTemplatesQuery = { __typename?: 'Query', vestingScheduleTemplates?: { __typename?: 'PaginatedVestingScheduleTemplateType', count: number, currentPage: number, pageData?: Array<{ __typename?: 'VestingScheduleTemplateType', id: string, name?: string | null, created: string, modified: string, vestingEvents?: Array<{ __typename?: 'VestingScheduleTemplateEventOutputType', vestingValuePercentage?: number | null, eventType?: string | null, vestingData?: { __typename?: 'VestingDataOutputType', description?: string | null, duration?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null, frequency?: { __typename?: 'VestingTimeSliceOutputType', value?: number | null, granularity?: VestingGranularityOutputField | null } | null } | null } | null> | null } | null> | null } | null };\n\nexport type CreateVestingScheduleTemplateMutationVariables = Exact<{\n  organisation: Scalars['OrganisationCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  vestingScheduleTemplate: VestingScheduleTemplateInputType;\n}>;\n\n\nexport type CreateVestingScheduleTemplateMutation = { __typename?: 'Mutation', createVestingScheduleTemplate?: boolean | null };\n\nexport type EditVestingScheduleTemplateMutationVariables = Exact<{\n  template: Scalars['VestingScheduleTemplateCakeType']['input'];\n  name: Scalars['CleanString']['input'];\n  vestingScheduleTemplate: VestingScheduleTemplateInputType;\n}>;\n\n\nexport type EditVestingScheduleTemplateMutation = { __typename?: 'Mutation', editVestingScheduleTemplate?: boolean | null };\n\nexport type DeleteVestingScheduleTemplateMutationVariables = Exact<{\n  vestingScheduleTemplate: Scalars['VestingScheduleTemplateCakeType']['input'];\n}>;\n\n\nexport type DeleteVestingScheduleTemplateMutation = { __typename?: 'Mutation', deleteVestingScheduleTemplate?: boolean | null };\n\nexport type GetDigestedPlanTransactionsQueryVariables = Exact<{\n  planType: VestingPlanType;\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetDigestedPlanTransactionsQuery = { __typename?: 'Query', digestedPlanTransactions?: { __typename?: 'PaginatedVestingPlanTransaction', count: number, currentPage: number, pageData?: Array<{ __typename?: 'VestingPlanTransaction', transactionDate?: string | null, planName?: string | null, transactionType?: string | null, vestingValue?: number | null, exercisePrice?: number | null, transactionId?: string | null, lastComment?: string | null, attachedDocumentId?: string | null, attachedDocumentName?: string | null, sharetype?: { __typename?: 'Sharetype', symbol: string } | null, shareholder?: { __typename?: 'Shareholder', id: string, displayName?: string | null, secondaryName?: string | null, avatar?: string | null, recipient?: { __typename?: 'Shareholder', id: string, displayName?: string | null } | null, trust?: { __typename?: 'TrustType', id: string } | null, investorData?: Array<{ __typename?: 'InvestorDataType', name: string, companyData?: { __typename?: 'CompanyDataType', identifierType?: IdentifierTypeOutputField | null } | null } | null> | null } | null } | null> | null } | null };\n\nexport type GetPlanOffersWarrantsQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  filterId?: InputMaybe<Scalars['UUID']['input']>;\n  page: Scalars['PositiveInteger']['input'];\n  itemsPerPage: Scalars['PositiveInteger']['input'];\n  filters?: InputMaybe<Array<ListFilterType> | ListFilterType>;\n  sort?: InputMaybe<Array<Scalars['CleanString']['input']> | Scalars['CleanString']['input']>;\n  search?: InputMaybe<Scalars['String']['input']>;\n}>;\n\n\nexport type GetPlanOffersWarrantsQuery = { __typename?: 'Query', offers?: { __typename?: 'PaginatedWarrantOffer', count: number, currentPage: number, notSignedUpCount?: number | null, shareholderCount?: number | null, plan?: { __typename?: 'WarrantOutputType', id: string, vestingValue?: number | null, totalOffered?: number | null, totalLapsed?: number | null, organisation: { __typename?: 'Organisation', fullyDilutedShares?: number | null } } | null, pageData?: Array<{ __typename?: 'ListContextVestingOfferType', id?: string | null, modified?: string | null, groupId?: string | null, planId?: string | null, offerLetterId?: string | null, dateGranted?: string | null, grantDateDefault?: string | null, vestStartDate?: string | null, emailsOn?: boolean | null, requireWitness?: boolean | null, shareholderId?: string | null, shareholderDisplayName?: string | null, shareholderSecondaryName?: string | null, shareholderAvatar?: string | null, shareholderHasLoggedIn?: boolean | null, shareholderConsideredInvited?: boolean | null, shEmail?: string | null, status?: string | null, softStatus?: string | null, country?: string | null, vestingValue?: number | null, availableToLapse?: number | null, availableToExercise?: number | null, availableToVest?: number | null, vested?: number | null, granted?: number | null, lapsed?: number | null, exercised?: number | null, hasOngoingPauseEvents?: boolean | null, hasScheduledPauseEvents?: boolean | null, stakeholderType?: string | null, isTrust?: boolean | null } | null> | null } | null };\n\nexport type GetPlanNamesWarrantQueryVariables = Exact<{\n  organisationId: Scalars['UUID']['input'];\n  page?: InputMaybe<Scalars['Int']['input']>;\n  itemsPerPage?: InputMaybe<Scalars['Int']['input']>;\n}>;\n\n\nexport type GetPlanNamesWarrantQuery = { __typename?: 'Query', warrants?: Array<{ __typename?: 'WarrantOutputType', id: string, name?: string | null } | null> | null };\n\nexport type GetExerciseDataWarrantQueryVariables = Exact<{\n  offer: Scalars['WarrantOfferCakeType']['input'];\n}>;\n\n\nexport type GetExerciseDataWarrantQuery = { __typename?: 'Query', investorHoldings?: { __typename?: 'GroupedWarrantHoldingType', availableToExercise?: number | null, availableToLapse?: number | null, availableToVestMilestone?: number | null, exercised?: number | null, offer?: { __typename?: 'WarrantOfferOutputType', id: string, currency?: string | null, exercisePrice: number, shareholder: { __typename?: 'Shareholder', id: string, displayName?: string | null, avatar?: string | null, organisation: { __typename?: 'Organisation', lastCertificateNumber?: number | null } } } | null } | null };\n\n\nexport const OrganisationDetailsDocument: TypedDocumentNode<OrganisationDetailsQuery, OrganisationDetailsQueryVariables> = gql`\n  query organisationDetails($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    id\n    name\n    country\n    currency\n    logoImage: logoImageLink\n    fundingPhase\n    created\n    companyDetails {\n      ... on AuCompanyDetailsField {\n        acn\n        registrationLocation\n        registeredAgentName\n        registeredAgentEmail\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on SgCompanyDetailsField {\n        uen\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on UsCompanyDetailsField {\n        stateOfRegistration\n        ein\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on GbCompanyDetailsField {\n        crn\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on NzCompanyDetailsField {\n        nzbn\n        registeredAgentName\n        registeredAgentEmail\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on InCompanyDetailsField {\n        cin\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on CaCompanyDetailsField {\n        bn\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on EeCompanyDetailsField {\n        brc\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n    }\n    officeholderSet {\n      id\n      name\n      email\n      roles {\n        role\n        name\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useOrganisationDetailsQuery__\n *\n * To run a query within a React component, call `useOrganisationDetailsQuery` and pass it any options that fit your needs.\n * When your component renders, `useOrganisationDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOrganisationDetailsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useOrganisationDetailsQuery(baseOptions: Apollo.QueryHookOptions<OrganisationDetailsQuery, OrganisationDetailsQueryVariables> & ({ variables: OrganisationDetailsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OrganisationDetailsQuery, OrganisationDetailsQueryVariables>(OrganisationDetailsDocument, options);\n      }\nexport function useOrganisationDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OrganisationDetailsQuery, OrganisationDetailsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OrganisationDetailsQuery, OrganisationDetailsQueryVariables>(OrganisationDetailsDocument, options);\n        }\nexport function useOrganisationDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OrganisationDetailsQuery, OrganisationDetailsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OrganisationDetailsQuery, OrganisationDetailsQueryVariables>(OrganisationDetailsDocument, options);\n        }\nexport type OrganisationDetailsQueryHookResult = ReturnType<typeof useOrganisationDetailsQuery>;\nexport type OrganisationDetailsLazyQueryHookResult = ReturnType<typeof useOrganisationDetailsLazyQuery>;\nexport type OrganisationDetailsSuspenseQueryHookResult = ReturnType<typeof useOrganisationDetailsSuspenseQuery>;\nexport type OrganisationDetailsQueryResult = Apollo.QueryResult<OrganisationDetailsQuery, OrganisationDetailsQueryVariables>;\nexport function refetchOrganisationDetailsQuery(variables: OrganisationDetailsQueryVariables) {\n      return { query: OrganisationDetailsDocument, variables: variables };\n    }\nexport const UserOrganisationStatusDocument: TypedDocumentNode<UserOrganisationStatusQuery, UserOrganisationStatusQueryVariables> = gql`\n  query userOrganisationStatus {\n  userOrgStatus {\n    organisationId\n    organisationName\n    hasValidLicense\n  }\n}\n    `;\n\n/**\n * __useUserOrganisationStatusQuery__\n *\n * To run a query within a React component, call `useUserOrganisationStatusQuery` and pass it any options that fit your needs.\n * When your component renders, `useUserOrganisationStatusQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useUserOrganisationStatusQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useUserOrganisationStatusQuery(baseOptions?: Apollo.QueryHookOptions<UserOrganisationStatusQuery, UserOrganisationStatusQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<UserOrganisationStatusQuery, UserOrganisationStatusQueryVariables>(UserOrganisationStatusDocument, options);\n      }\nexport function useUserOrganisationStatusLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UserOrganisationStatusQuery, UserOrganisationStatusQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<UserOrganisationStatusQuery, UserOrganisationStatusQueryVariables>(UserOrganisationStatusDocument, options);\n        }\nexport function useUserOrganisationStatusSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserOrganisationStatusQuery, UserOrganisationStatusQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<UserOrganisationStatusQuery, UserOrganisationStatusQueryVariables>(UserOrganisationStatusDocument, options);\n        }\nexport type UserOrganisationStatusQueryHookResult = ReturnType<typeof useUserOrganisationStatusQuery>;\nexport type UserOrganisationStatusLazyQueryHookResult = ReturnType<typeof useUserOrganisationStatusLazyQuery>;\nexport type UserOrganisationStatusSuspenseQueryHookResult = ReturnType<typeof useUserOrganisationStatusSuspenseQuery>;\nexport type UserOrganisationStatusQueryResult = Apollo.QueryResult<UserOrganisationStatusQuery, UserOrganisationStatusQueryVariables>;\nexport function refetchUserOrganisationStatusQuery(variables?: UserOrganisationStatusQueryVariables) {\n      return { query: UserOrganisationStatusDocument, variables: variables };\n    }\nexport const SendEmployeeLicenseBlockEmailDocument: TypedDocumentNode<SendEmployeeLicenseBlockEmailMutation, SendEmployeeLicenseBlockEmailMutationVariables> = gql`\n  mutation sendEmployeeLicenseBlockEmail($organisationId: UUID!) {\n  sendEmployeeLicenseBlockEmail(organisationId: $organisationId)\n}\n    `;\nexport type SendEmployeeLicenseBlockEmailMutationFn = Apollo.MutationFunction<SendEmployeeLicenseBlockEmailMutation, SendEmployeeLicenseBlockEmailMutationVariables>;\n\n/**\n * __useSendEmployeeLicenseBlockEmailMutation__\n *\n * To run a mutation, you first call `useSendEmployeeLicenseBlockEmailMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSendEmployeeLicenseBlockEmailMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [sendEmployeeLicenseBlockEmailMutation, { data, loading, error }] = useSendEmployeeLicenseBlockEmailMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useSendEmployeeLicenseBlockEmailMutation(baseOptions?: Apollo.MutationHookOptions<SendEmployeeLicenseBlockEmailMutation, SendEmployeeLicenseBlockEmailMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SendEmployeeLicenseBlockEmailMutation, SendEmployeeLicenseBlockEmailMutationVariables>(SendEmployeeLicenseBlockEmailDocument, options);\n      }\nexport type SendEmployeeLicenseBlockEmailMutationHookResult = ReturnType<typeof useSendEmployeeLicenseBlockEmailMutation>;\nexport type SendEmployeeLicenseBlockEmailMutationResult = Apollo.MutationResult<SendEmployeeLicenseBlockEmailMutation>;\nexport type SendEmployeeLicenseBlockEmailMutationOptions = Apollo.BaseMutationOptions<SendEmployeeLicenseBlockEmailMutation, SendEmployeeLicenseBlockEmailMutationVariables>;\nexport const DocumentsHomeDocument: TypedDocumentNode<DocumentsHomeQuery, DocumentsHomeQueryVariables> = gql`\n  query DocumentsHome($page: Int, $itemsPerPage: Int) {\n  shareholderDocs(page: $page, itemsPerPage: $itemsPerPage) {\n    pageData {\n      id\n      name\n      modified\n      extension\n      organisation {\n        logoImageLink\n        name\n        id\n      }\n    }\n    currentPage\n    count\n  }\n}\n    `;\n\n/**\n * __useDocumentsHomeQuery__\n *\n * To run a query within a React component, call `useDocumentsHomeQuery` and pass it any options that fit your needs.\n * When your component renders, `useDocumentsHomeQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDocumentsHomeQuery({\n *   variables: {\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useDocumentsHomeQuery(baseOptions?: Apollo.QueryHookOptions<DocumentsHomeQuery, DocumentsHomeQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DocumentsHomeQuery, DocumentsHomeQueryVariables>(DocumentsHomeDocument, options);\n      }\nexport function useDocumentsHomeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DocumentsHomeQuery, DocumentsHomeQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DocumentsHomeQuery, DocumentsHomeQueryVariables>(DocumentsHomeDocument, options);\n        }\nexport function useDocumentsHomeSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DocumentsHomeQuery, DocumentsHomeQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DocumentsHomeQuery, DocumentsHomeQueryVariables>(DocumentsHomeDocument, options);\n        }\nexport type DocumentsHomeQueryHookResult = ReturnType<typeof useDocumentsHomeQuery>;\nexport type DocumentsHomeLazyQueryHookResult = ReturnType<typeof useDocumentsHomeLazyQuery>;\nexport type DocumentsHomeSuspenseQueryHookResult = ReturnType<typeof useDocumentsHomeSuspenseQuery>;\nexport type DocumentsHomeQueryResult = Apollo.QueryResult<DocumentsHomeQuery, DocumentsHomeQueryVariables>;\nexport function refetchDocumentsHomeQuery(variables?: DocumentsHomeQueryVariables) {\n      return { query: DocumentsHomeDocument, variables: variables };\n    }\nexport const HomeEntrypointDocument: TypedDocumentNode<HomeEntrypointQuery, HomeEntrypointQueryVariables> = gql`\n  query HomeEntrypoint {\n  homeEntrypoint {\n    hasSecurities\n    hasPendingOffers\n    ongoingCliff\n    ongoingVestingList {\n      __typename\n      ... on EsopOffer {\n        id\n      }\n      ... on EssOffer {\n        id\n      }\n      ... on RsuOfferOutputType {\n        id\n      }\n      ... on WarrantOfferOutputType {\n        id\n      }\n    }\n    hasUnreadMessages\n    hasDocuments\n  }\n}\n    `;\n\n/**\n * __useHomeEntrypointQuery__\n *\n * To run a query within a React component, call `useHomeEntrypointQuery` and pass it any options that fit your needs.\n * When your component renders, `useHomeEntrypointQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useHomeEntrypointQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useHomeEntrypointQuery(baseOptions?: Apollo.QueryHookOptions<HomeEntrypointQuery, HomeEntrypointQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<HomeEntrypointQuery, HomeEntrypointQueryVariables>(HomeEntrypointDocument, options);\n      }\nexport function useHomeEntrypointLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<HomeEntrypointQuery, HomeEntrypointQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<HomeEntrypointQuery, HomeEntrypointQueryVariables>(HomeEntrypointDocument, options);\n        }\nexport function useHomeEntrypointSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<HomeEntrypointQuery, HomeEntrypointQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<HomeEntrypointQuery, HomeEntrypointQueryVariables>(HomeEntrypointDocument, options);\n        }\nexport type HomeEntrypointQueryHookResult = ReturnType<typeof useHomeEntrypointQuery>;\nexport type HomeEntrypointLazyQueryHookResult = ReturnType<typeof useHomeEntrypointLazyQuery>;\nexport type HomeEntrypointSuspenseQueryHookResult = ReturnType<typeof useHomeEntrypointSuspenseQuery>;\nexport type HomeEntrypointQueryResult = Apollo.QueryResult<HomeEntrypointQuery, HomeEntrypointQueryVariables>;\nexport function refetchHomeEntrypointQuery(variables?: HomeEntrypointQueryVariables) {\n      return { query: HomeEntrypointDocument, variables: variables };\n    }\nexport const UserOrganisationsDocument: TypedDocumentNode<UserOrganisationsQuery, UserOrganisationsQueryVariables> = gql`\n  query userOrganisations {\n  userOrganisations {\n    hasVisibleValuation\n    exchangeRates {\n      fromCurrency\n      toCurrency\n      rate\n    }\n    organisationData {\n      id\n      name\n      logo\n      currency\n      valuation\n      fullyDiluted\n    }\n  }\n}\n    `;\n\n/**\n * __useUserOrganisationsQuery__\n *\n * To run a query within a React component, call `useUserOrganisationsQuery` and pass it any options that fit your needs.\n * When your component renders, `useUserOrganisationsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useUserOrganisationsQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useUserOrganisationsQuery(baseOptions?: Apollo.QueryHookOptions<UserOrganisationsQuery, UserOrganisationsQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<UserOrganisationsQuery, UserOrganisationsQueryVariables>(UserOrganisationsDocument, options);\n      }\nexport function useUserOrganisationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UserOrganisationsQuery, UserOrganisationsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<UserOrganisationsQuery, UserOrganisationsQueryVariables>(UserOrganisationsDocument, options);\n        }\nexport function useUserOrganisationsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserOrganisationsQuery, UserOrganisationsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<UserOrganisationsQuery, UserOrganisationsQueryVariables>(UserOrganisationsDocument, options);\n        }\nexport type UserOrganisationsQueryHookResult = ReturnType<typeof useUserOrganisationsQuery>;\nexport type UserOrganisationsLazyQueryHookResult = ReturnType<typeof useUserOrganisationsLazyQuery>;\nexport type UserOrganisationsSuspenseQueryHookResult = ReturnType<typeof useUserOrganisationsSuspenseQuery>;\nexport type UserOrganisationsQueryResult = Apollo.QueryResult<UserOrganisationsQuery, UserOrganisationsQueryVariables>;\nexport function refetchUserOrganisationsQuery(variables?: UserOrganisationsQueryVariables) {\n      return { query: UserOrganisationsDocument, variables: variables };\n    }\nexport const HomeDocumentsDocument: TypedDocumentNode<HomeDocumentsQuery, HomeDocumentsQueryVariables> = gql`\n  query HomeDocuments($page: Int, $itemsPerPage: Int) {\n  shareholderDocs(page: $page, itemsPerPage: $itemsPerPage) {\n    pageData {\n      id\n      name\n      modified\n      extension\n      organisation {\n        logo\n        name\n        id\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useHomeDocumentsQuery__\n *\n * To run a query within a React component, call `useHomeDocumentsQuery` and pass it any options that fit your needs.\n * When your component renders, `useHomeDocumentsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useHomeDocumentsQuery({\n *   variables: {\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useHomeDocumentsQuery(baseOptions?: Apollo.QueryHookOptions<HomeDocumentsQuery, HomeDocumentsQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<HomeDocumentsQuery, HomeDocumentsQueryVariables>(HomeDocumentsDocument, options);\n      }\nexport function useHomeDocumentsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<HomeDocumentsQuery, HomeDocumentsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<HomeDocumentsQuery, HomeDocumentsQueryVariables>(HomeDocumentsDocument, options);\n        }\nexport function useHomeDocumentsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<HomeDocumentsQuery, HomeDocumentsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<HomeDocumentsQuery, HomeDocumentsQueryVariables>(HomeDocumentsDocument, options);\n        }\nexport type HomeDocumentsQueryHookResult = ReturnType<typeof useHomeDocumentsQuery>;\nexport type HomeDocumentsLazyQueryHookResult = ReturnType<typeof useHomeDocumentsLazyQuery>;\nexport type HomeDocumentsSuspenseQueryHookResult = ReturnType<typeof useHomeDocumentsSuspenseQuery>;\nexport type HomeDocumentsQueryResult = Apollo.QueryResult<HomeDocumentsQuery, HomeDocumentsQueryVariables>;\nexport function refetchHomeDocumentsQuery(variables?: HomeDocumentsQueryVariables) {\n      return { query: HomeDocumentsDocument, variables: variables };\n    }\nexport const HomeMessagesDocument: TypedDocumentNode<HomeMessagesQuery, HomeMessagesQueryVariables> = gql`\n  query HomeMessages($page: PositiveInteger, $itemsPerPage: PositiveInteger) {\n  investorMessages(page: $page, itemsPerPage: $itemsPerPage) {\n    pageData {\n      id\n      subject\n      bodyParsed\n      created\n      attachments {\n        id\n      }\n      user {\n        firstName\n        lastName\n        picture\n      }\n      organisation {\n        id\n        name\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useHomeMessagesQuery__\n *\n * To run a query within a React component, call `useHomeMessagesQuery` and pass it any options that fit your needs.\n * When your component renders, `useHomeMessagesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useHomeMessagesQuery({\n *   variables: {\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useHomeMessagesQuery(baseOptions?: Apollo.QueryHookOptions<HomeMessagesQuery, HomeMessagesQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<HomeMessagesQuery, HomeMessagesQueryVariables>(HomeMessagesDocument, options);\n      }\nexport function useHomeMessagesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<HomeMessagesQuery, HomeMessagesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<HomeMessagesQuery, HomeMessagesQueryVariables>(HomeMessagesDocument, options);\n        }\nexport function useHomeMessagesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<HomeMessagesQuery, HomeMessagesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<HomeMessagesQuery, HomeMessagesQueryVariables>(HomeMessagesDocument, options);\n        }\nexport type HomeMessagesQueryHookResult = ReturnType<typeof useHomeMessagesQuery>;\nexport type HomeMessagesLazyQueryHookResult = ReturnType<typeof useHomeMessagesLazyQuery>;\nexport type HomeMessagesSuspenseQueryHookResult = ReturnType<typeof useHomeMessagesSuspenseQuery>;\nexport type HomeMessagesQueryResult = Apollo.QueryResult<HomeMessagesQuery, HomeMessagesQueryVariables>;\nexport function refetchHomeMessagesQuery(variables?: HomeMessagesQueryVariables) {\n      return { query: HomeMessagesDocument, variables: variables };\n    }\nexport const HomePortfolioDocument: TypedDocumentNode<HomePortfolioQuery, HomePortfolioQueryVariables> = gql`\n  query HomePortfolio {\n  portfolioHome {\n    shareholder {\n      id\n      organisation {\n        id\n        name\n        logo\n      }\n    }\n    groupedShareholdings {\n      totalShares\n      __typename\n    }\n    groupedShareholdingsInTrust {\n      totalShares\n      __typename\n    }\n    groupedNoteholdings(excludeResolved: true) {\n      totalNotes\n      totalInvested\n      __typename\n    }\n    groupedPlanData {\n      planType\n      totalGranted\n      totalVested\n      totalExercised\n      totalLapsed\n      vestingNext {\n        vestingValue\n      }\n      __typename\n    }\n  }\n}\n    `;\n\n/**\n * __useHomePortfolioQuery__\n *\n * To run a query within a React component, call `useHomePortfolioQuery` and pass it any options that fit your needs.\n * When your component renders, `useHomePortfolioQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useHomePortfolioQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useHomePortfolioQuery(baseOptions?: Apollo.QueryHookOptions<HomePortfolioQuery, HomePortfolioQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<HomePortfolioQuery, HomePortfolioQueryVariables>(HomePortfolioDocument, options);\n      }\nexport function useHomePortfolioLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<HomePortfolioQuery, HomePortfolioQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<HomePortfolioQuery, HomePortfolioQueryVariables>(HomePortfolioDocument, options);\n        }\nexport function useHomePortfolioSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<HomePortfolioQuery, HomePortfolioQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<HomePortfolioQuery, HomePortfolioQueryVariables>(HomePortfolioDocument, options);\n        }\nexport type HomePortfolioQueryHookResult = ReturnType<typeof useHomePortfolioQuery>;\nexport type HomePortfolioLazyQueryHookResult = ReturnType<typeof useHomePortfolioLazyQuery>;\nexport type HomePortfolioSuspenseQueryHookResult = ReturnType<typeof useHomePortfolioSuspenseQuery>;\nexport type HomePortfolioQueryResult = Apollo.QueryResult<HomePortfolioQuery, HomePortfolioQueryVariables>;\nexport function refetchHomePortfolioQuery(variables?: HomePortfolioQueryVariables) {\n      return { query: HomePortfolioDocument, variables: variables };\n    }\nexport const HomeOffersPendingDocument: TypedDocumentNode<HomeOffersPendingQuery, HomeOffersPendingQueryVariables> = gql`\n  query HomeOffersPending {\n  userOffers {\n    __typename\n    ... on EsopOffer {\n      id\n      modified\n      group {\n        plan {\n          organisation {\n            id\n            name\n            logo: logoImageLink\n          }\n        }\n      }\n    }\n    ... on EssOffer {\n      id\n      modified\n      group {\n        plan {\n          organisation {\n            id\n            name\n            logo: logoImageLink\n          }\n        }\n      }\n    }\n    ... on RsuOfferOutputType {\n      id\n      modified\n      group {\n        plan {\n          organisation {\n            id\n            name\n            logo: logoImageLink\n          }\n        }\n      }\n    }\n    ... on OrganisationRaiseOffer {\n      id\n      modified\n      organisationRaise {\n        organisation {\n          id\n          name\n          logo: logoImageLink\n        }\n      }\n    }\n    ... on NotesRoundOfferType {\n      id\n      modified\n      notesRound {\n        organisation {\n          id\n          name\n          logo: logoImageLink\n        }\n      }\n    }\n    ... on ShareTransferOfferType {\n      id\n      modified\n      sharetype {\n        organisation {\n          id\n          name\n          logo: logoImageLink\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useHomeOffersPendingQuery__\n *\n * To run a query within a React component, call `useHomeOffersPendingQuery` and pass it any options that fit your needs.\n * When your component renders, `useHomeOffersPendingQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useHomeOffersPendingQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useHomeOffersPendingQuery(baseOptions?: Apollo.QueryHookOptions<HomeOffersPendingQuery, HomeOffersPendingQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<HomeOffersPendingQuery, HomeOffersPendingQueryVariables>(HomeOffersPendingDocument, options);\n      }\nexport function useHomeOffersPendingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<HomeOffersPendingQuery, HomeOffersPendingQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<HomeOffersPendingQuery, HomeOffersPendingQueryVariables>(HomeOffersPendingDocument, options);\n        }\nexport function useHomeOffersPendingSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<HomeOffersPendingQuery, HomeOffersPendingQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<HomeOffersPendingQuery, HomeOffersPendingQueryVariables>(HomeOffersPendingDocument, options);\n        }\nexport type HomeOffersPendingQueryHookResult = ReturnType<typeof useHomeOffersPendingQuery>;\nexport type HomeOffersPendingLazyQueryHookResult = ReturnType<typeof useHomeOffersPendingLazyQuery>;\nexport type HomeOffersPendingSuspenseQueryHookResult = ReturnType<typeof useHomeOffersPendingSuspenseQuery>;\nexport type HomeOffersPendingQueryResult = Apollo.QueryResult<HomeOffersPendingQuery, HomeOffersPendingQueryVariables>;\nexport function refetchHomeOffersPendingQuery(variables?: HomeOffersPendingQueryVariables) {\n      return { query: HomeOffersPendingDocument, variables: variables };\n    }\nexport const UserEmployeeGoalDocument: TypedDocumentNode<UserEmployeeGoalQuery, UserEmployeeGoalQueryVariables> = gql`\n  query UserEmployeeGoal {\n  userEmployeeGoal {\n    emotion\n    goal\n    meaning\n  }\n}\n    `;\n\n/**\n * __useUserEmployeeGoalQuery__\n *\n * To run a query within a React component, call `useUserEmployeeGoalQuery` and pass it any options that fit your needs.\n * When your component renders, `useUserEmployeeGoalQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useUserEmployeeGoalQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useUserEmployeeGoalQuery(baseOptions?: Apollo.QueryHookOptions<UserEmployeeGoalQuery, UserEmployeeGoalQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<UserEmployeeGoalQuery, UserEmployeeGoalQueryVariables>(UserEmployeeGoalDocument, options);\n      }\nexport function useUserEmployeeGoalLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UserEmployeeGoalQuery, UserEmployeeGoalQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<UserEmployeeGoalQuery, UserEmployeeGoalQueryVariables>(UserEmployeeGoalDocument, options);\n        }\nexport function useUserEmployeeGoalSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserEmployeeGoalQuery, UserEmployeeGoalQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<UserEmployeeGoalQuery, UserEmployeeGoalQueryVariables>(UserEmployeeGoalDocument, options);\n        }\nexport type UserEmployeeGoalQueryHookResult = ReturnType<typeof useUserEmployeeGoalQuery>;\nexport type UserEmployeeGoalLazyQueryHookResult = ReturnType<typeof useUserEmployeeGoalLazyQuery>;\nexport type UserEmployeeGoalSuspenseQueryHookResult = ReturnType<typeof useUserEmployeeGoalSuspenseQuery>;\nexport type UserEmployeeGoalQueryResult = Apollo.QueryResult<UserEmployeeGoalQuery, UserEmployeeGoalQueryVariables>;\nexport function refetchUserEmployeeGoalQuery(variables?: UserEmployeeGoalQueryVariables) {\n      return { query: UserEmployeeGoalDocument, variables: variables };\n    }\nexport const VestingCliffDocument: TypedDocumentNode<VestingCliffQuery, VestingCliffQueryVariables> = gql`\n  query vestingCliff($eventId: UUID!) {\n  vestingCliff(eventId: $eventId) {\n    vestStartDate\n    vestingData {\n      duration {\n        value\n        granularity\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useVestingCliffQuery__\n *\n * To run a query within a React component, call `useVestingCliffQuery` and pass it any options that fit your needs.\n * When your component renders, `useVestingCliffQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useVestingCliffQuery({\n *   variables: {\n *      eventId: // value for 'eventId'\n *   },\n * });\n */\nexport function useVestingCliffQuery(baseOptions: Apollo.QueryHookOptions<VestingCliffQuery, VestingCliffQueryVariables> & ({ variables: VestingCliffQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<VestingCliffQuery, VestingCliffQueryVariables>(VestingCliffDocument, options);\n      }\nexport function useVestingCliffLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<VestingCliffQuery, VestingCliffQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<VestingCliffQuery, VestingCliffQueryVariables>(VestingCliffDocument, options);\n        }\nexport function useVestingCliffSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<VestingCliffQuery, VestingCliffQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<VestingCliffQuery, VestingCliffQueryVariables>(VestingCliffDocument, options);\n        }\nexport type VestingCliffQueryHookResult = ReturnType<typeof useVestingCliffQuery>;\nexport type VestingCliffLazyQueryHookResult = ReturnType<typeof useVestingCliffLazyQuery>;\nexport type VestingCliffSuspenseQueryHookResult = ReturnType<typeof useVestingCliffSuspenseQuery>;\nexport type VestingCliffQueryResult = Apollo.QueryResult<VestingCliffQuery, VestingCliffQueryVariables>;\nexport function refetchVestingCliffQuery(variables: VestingCliffQueryVariables) {\n      return { query: VestingCliffDocument, variables: variables };\n    }\nexport const HomeOffersEarningChartDocument: TypedDocumentNode<HomeOffersEarningChartQuery, HomeOffersEarningChartQueryVariables> = gql`\n  query HomeOffersEarningChart {\n  esopOfferList {\n    __typename\n    id\n    group {\n      id\n      plan {\n        name\n        organisation {\n          id\n        }\n      }\n      country\n    }\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    granted\n    vested\n  }\n  essOfferList {\n    __typename\n    id\n    group {\n      id\n      plan {\n        name\n        organisation {\n          id\n        }\n      }\n      country\n    }\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    granted\n    vested\n  }\n  rsuOfferList {\n    __typename\n    id\n    group {\n      id\n      plan {\n        name\n        organisation {\n          id\n        }\n      }\n      country\n    }\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    granted\n    vested\n  }\n  warrantOfferList {\n    __typename\n    id\n    group {\n      id\n      plan {\n        name\n        organisation {\n          id\n        }\n      }\n      country\n    }\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    granted\n    vested\n  }\n}\n    `;\n\n/**\n * __useHomeOffersEarningChartQuery__\n *\n * To run a query within a React component, call `useHomeOffersEarningChartQuery` and pass it any options that fit your needs.\n * When your component renders, `useHomeOffersEarningChartQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useHomeOffersEarningChartQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useHomeOffersEarningChartQuery(baseOptions?: Apollo.QueryHookOptions<HomeOffersEarningChartQuery, HomeOffersEarningChartQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<HomeOffersEarningChartQuery, HomeOffersEarningChartQueryVariables>(HomeOffersEarningChartDocument, options);\n      }\nexport function useHomeOffersEarningChartLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<HomeOffersEarningChartQuery, HomeOffersEarningChartQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<HomeOffersEarningChartQuery, HomeOffersEarningChartQueryVariables>(HomeOffersEarningChartDocument, options);\n        }\nexport function useHomeOffersEarningChartSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<HomeOffersEarningChartQuery, HomeOffersEarningChartQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<HomeOffersEarningChartQuery, HomeOffersEarningChartQueryVariables>(HomeOffersEarningChartDocument, options);\n        }\nexport type HomeOffersEarningChartQueryHookResult = ReturnType<typeof useHomeOffersEarningChartQuery>;\nexport type HomeOffersEarningChartLazyQueryHookResult = ReturnType<typeof useHomeOffersEarningChartLazyQuery>;\nexport type HomeOffersEarningChartSuspenseQueryHookResult = ReturnType<typeof useHomeOffersEarningChartSuspenseQuery>;\nexport type HomeOffersEarningChartQueryResult = Apollo.QueryResult<HomeOffersEarningChartQuery, HomeOffersEarningChartQueryVariables>;\nexport function refetchHomeOffersEarningChartQuery(variables?: HomeOffersEarningChartQueryVariables) {\n      return { query: HomeOffersEarningChartDocument, variables: variables };\n    }\nexport const SetUserEmployeeGoalDocument: TypedDocumentNode<SetUserEmployeeGoalMutation, SetUserEmployeeGoalMutationVariables> = gql`\n  mutation setUserEmployeeGoal($emotion: CleanString!, $goal: CleanString!, $meaning: CleanString!) {\n  setUserEmployeeGoal(emotion: $emotion, goal: $goal, meaning: $meaning)\n}\n    `;\nexport type SetUserEmployeeGoalMutationFn = Apollo.MutationFunction<SetUserEmployeeGoalMutation, SetUserEmployeeGoalMutationVariables>;\n\n/**\n * __useSetUserEmployeeGoalMutation__\n *\n * To run a mutation, you first call `useSetUserEmployeeGoalMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSetUserEmployeeGoalMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [setUserEmployeeGoalMutation, { data, loading, error }] = useSetUserEmployeeGoalMutation({\n *   variables: {\n *      emotion: // value for 'emotion'\n *      goal: // value for 'goal'\n *      meaning: // value for 'meaning'\n *   },\n * });\n */\nexport function useSetUserEmployeeGoalMutation(baseOptions?: Apollo.MutationHookOptions<SetUserEmployeeGoalMutation, SetUserEmployeeGoalMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SetUserEmployeeGoalMutation, SetUserEmployeeGoalMutationVariables>(SetUserEmployeeGoalDocument, options);\n      }\nexport type SetUserEmployeeGoalMutationHookResult = ReturnType<typeof useSetUserEmployeeGoalMutation>;\nexport type SetUserEmployeeGoalMutationResult = Apollo.MutationResult<SetUserEmployeeGoalMutation>;\nexport type SetUserEmployeeGoalMutationOptions = Apollo.BaseMutationOptions<SetUserEmployeeGoalMutation, SetUserEmployeeGoalMutationVariables>;\nexport const InvestorInboxDocument: TypedDocumentNode<InvestorInboxQuery, InvestorInboxQueryVariables> = gql`\n  query investorInbox($page: PositiveInteger!, $itemsPerPage: PositiveInteger!) {\n  investorInbox(page: $page, itemsPerPage: $itemsPerPage) {\n    count\n    currentPage\n    pageData {\n      id\n      organisationId\n      organisationName\n      avatarImage\n      avatarName\n      threadLength\n      created\n      subject\n      nRecipients\n      hasAttachments\n      hasUnreadMessages\n      lastMessageStatus\n    }\n  }\n}\n    `;\n\n/**\n * __useInvestorInboxQuery__\n *\n * To run a query within a React component, call `useInvestorInboxQuery` and pass it any options that fit your needs.\n * When your component renders, `useInvestorInboxQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useInvestorInboxQuery({\n *   variables: {\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useInvestorInboxQuery(baseOptions: Apollo.QueryHookOptions<InvestorInboxQuery, InvestorInboxQueryVariables> & ({ variables: InvestorInboxQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<InvestorInboxQuery, InvestorInboxQueryVariables>(InvestorInboxDocument, options);\n      }\nexport function useInvestorInboxLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<InvestorInboxQuery, InvestorInboxQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<InvestorInboxQuery, InvestorInboxQueryVariables>(InvestorInboxDocument, options);\n        }\nexport function useInvestorInboxSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<InvestorInboxQuery, InvestorInboxQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<InvestorInboxQuery, InvestorInboxQueryVariables>(InvestorInboxDocument, options);\n        }\nexport type InvestorInboxQueryHookResult = ReturnType<typeof useInvestorInboxQuery>;\nexport type InvestorInboxLazyQueryHookResult = ReturnType<typeof useInvestorInboxLazyQuery>;\nexport type InvestorInboxSuspenseQueryHookResult = ReturnType<typeof useInvestorInboxSuspenseQuery>;\nexport type InvestorInboxQueryResult = Apollo.QueryResult<InvestorInboxQuery, InvestorInboxQueryVariables>;\nexport function refetchInvestorInboxQuery(variables: InvestorInboxQueryVariables) {\n      return { query: InvestorInboxDocument, variables: variables };\n    }\nexport const InvestorMessageThreadDocument: TypedDocumentNode<InvestorMessageThreadQuery, InvestorMessageThreadQueryVariables> = gql`\n  query investorMessageThread($replyThreadId: CakeReplyThreadCakeType!, $page: PositiveInteger, $itemsPerPage: PositiveInteger, $inReply: Boolean = false) {\n  investorMessageThread(replyThread: $replyThreadId) {\n    id\n    participants @include(if: $inReply) {\n      id\n      displayName\n      avatar\n    }\n    replyingShareholders(isCompany: false) {\n      id\n      displayName\n      avatar\n    }\n    rootMessage {\n      replyThread {\n        id\n      }\n      allowReactions\n      allowReplies\n      ownReaction\n      reactionAggregates {\n        reaction\n        count\n        stakeholders\n      }\n      id\n      created\n      subject\n      body\n      bodyParsed\n      isSeen(isCompany: false)\n      isDraft\n      attachments {\n        id\n        name\n        modified\n        extension\n      }\n      user {\n        firstName\n        lastName\n        picture\n      }\n      organisation {\n        id\n        name\n        logo: logoImageLink\n      }\n      allowReplies\n    }\n    messages: investorMessages(page: $page, itemsPerPage: $itemsPerPage) {\n      pageData {\n        created\n        id\n        subject\n        body\n        isDraft\n        isSeen(isCompany: false)\n        isCompanyMessage\n        organisation {\n          id\n          name\n          logo: logoImageLink\n        }\n        user {\n          firstName\n          lastName\n          picture\n        }\n        attachments {\n          id\n          name\n          modified\n          extension\n        }\n      }\n      count\n      currentPage\n    }\n  }\n}\n    `;\n\n/**\n * __useInvestorMessageThreadQuery__\n *\n * To run a query within a React component, call `useInvestorMessageThreadQuery` and pass it any options that fit your needs.\n * When your component renders, `useInvestorMessageThreadQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useInvestorMessageThreadQuery({\n *   variables: {\n *      replyThreadId: // value for 'replyThreadId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      inReply: // value for 'inReply'\n *   },\n * });\n */\nexport function useInvestorMessageThreadQuery(baseOptions: Apollo.QueryHookOptions<InvestorMessageThreadQuery, InvestorMessageThreadQueryVariables> & ({ variables: InvestorMessageThreadQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<InvestorMessageThreadQuery, InvestorMessageThreadQueryVariables>(InvestorMessageThreadDocument, options);\n      }\nexport function useInvestorMessageThreadLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<InvestorMessageThreadQuery, InvestorMessageThreadQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<InvestorMessageThreadQuery, InvestorMessageThreadQueryVariables>(InvestorMessageThreadDocument, options);\n        }\nexport function useInvestorMessageThreadSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<InvestorMessageThreadQuery, InvestorMessageThreadQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<InvestorMessageThreadQuery, InvestorMessageThreadQueryVariables>(InvestorMessageThreadDocument, options);\n        }\nexport type InvestorMessageThreadQueryHookResult = ReturnType<typeof useInvestorMessageThreadQuery>;\nexport type InvestorMessageThreadLazyQueryHookResult = ReturnType<typeof useInvestorMessageThreadLazyQuery>;\nexport type InvestorMessageThreadSuspenseQueryHookResult = ReturnType<typeof useInvestorMessageThreadSuspenseQuery>;\nexport type InvestorMessageThreadQueryResult = Apollo.QueryResult<InvestorMessageThreadQuery, InvestorMessageThreadQueryVariables>;\nexport function refetchInvestorMessageThreadQuery(variables: InvestorMessageThreadQueryVariables) {\n      return { query: InvestorMessageThreadDocument, variables: variables };\n    }\nexport const MessageReactionUpdateDocument: TypedDocumentNode<MessageReactionUpdateMutation, MessageReactionUpdateMutationVariables> = gql`\n  mutation MessageReactionUpdate($message: CakeMessageCakeType!, $reaction: CleanString!) {\n  updateMessageReaction(message: $message, reaction: $reaction)\n}\n    `;\nexport type MessageReactionUpdateMutationFn = Apollo.MutationFunction<MessageReactionUpdateMutation, MessageReactionUpdateMutationVariables>;\n\n/**\n * __useMessageReactionUpdateMutation__\n *\n * To run a mutation, you first call `useMessageReactionUpdateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useMessageReactionUpdateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [messageReactionUpdateMutation, { data, loading, error }] = useMessageReactionUpdateMutation({\n *   variables: {\n *      message: // value for 'message'\n *      reaction: // value for 'reaction'\n *   },\n * });\n */\nexport function useMessageReactionUpdateMutation(baseOptions?: Apollo.MutationHookOptions<MessageReactionUpdateMutation, MessageReactionUpdateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<MessageReactionUpdateMutation, MessageReactionUpdateMutationVariables>(MessageReactionUpdateDocument, options);\n      }\nexport type MessageReactionUpdateMutationHookResult = ReturnType<typeof useMessageReactionUpdateMutation>;\nexport type MessageReactionUpdateMutationResult = Apollo.MutationResult<MessageReactionUpdateMutation>;\nexport type MessageReactionUpdateMutationOptions = Apollo.BaseMutationOptions<MessageReactionUpdateMutation, MessageReactionUpdateMutationVariables>;\nexport const OffersHomeDocument: TypedDocumentNode<OffersHomeQuery, OffersHomeQueryVariables> = gql`\n  query OffersHome {\n  userOffers {\n    __typename\n    ... on EsopOffer {\n      id\n      modified\n      softStatus\n      exercisePrice\n      optionPrice\n      shareholder {\n        displayName\n      }\n      group {\n        plan {\n          name\n          organisation {\n            id\n            country\n            currency\n            name\n            logo: logoImageLink\n          }\n        }\n        currency\n      }\n      vestingEvents {\n        vestingValue\n      }\n      currency\n    }\n    ... on EssOffer {\n      id\n      modified\n      softStatus\n      shareholder {\n        displayName\n        organisation {\n          type\n        }\n      }\n      group {\n        plan {\n          name\n          organisation {\n            id\n            country\n            currency\n            name\n            logo: logoImageLink\n          }\n        }\n      }\n      vestingEvents {\n        vestingValue\n      }\n    }\n    ... on RsuOfferOutputType {\n      id\n      modified\n      softStatus\n      shareholder {\n        displayName\n      }\n      group {\n        plan {\n          name\n          organisation {\n            id\n            country\n            currency\n            name\n            logo: logoImageLink\n          }\n        }\n      }\n      vestingEvents {\n        vestingValue\n      }\n    }\n    ... on OrganisationRaiseOffer {\n      id\n      amount\n      paid\n      equityStatus: status\n      contract {\n        id\n      }\n      organisationRaise {\n        name\n        raiseGoalAmount\n        organisation {\n          id\n          country\n          currency\n          name\n          logo: logoImageLink\n        }\n      }\n    }\n    ... on NotesRoundOfferType {\n      id\n      principal\n      paid\n      notesStatus: status\n      contract {\n        id\n      }\n      notesRound {\n        name\n        roundInvestmentGoal\n        noteType\n        organisation {\n          id\n          country\n          currency\n          name\n          logo: logoImageLink\n        }\n      }\n    }\n    ... on ShareTransferOfferType {\n      id\n      isSeller\n      shares\n      amount\n      status\n      shareTransferAgreementContract {\n        id\n      }\n      fromShareholder {\n        displayName\n        avatar\n        investorData {\n          email\n        }\n      }\n      toShareholder {\n        displayName\n        avatar\n        investorData {\n          email\n        }\n      }\n      sharetype {\n        symbol\n        organisation {\n          id\n          country\n          currency\n          name\n          logo: logoImageLink\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useOffersHomeQuery__\n *\n * To run a query within a React component, call `useOffersHomeQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffersHomeQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffersHomeQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useOffersHomeQuery(baseOptions?: Apollo.QueryHookOptions<OffersHomeQuery, OffersHomeQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffersHomeQuery, OffersHomeQueryVariables>(OffersHomeDocument, options);\n      }\nexport function useOffersHomeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffersHomeQuery, OffersHomeQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffersHomeQuery, OffersHomeQueryVariables>(OffersHomeDocument, options);\n        }\nexport function useOffersHomeSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffersHomeQuery, OffersHomeQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffersHomeQuery, OffersHomeQueryVariables>(OffersHomeDocument, options);\n        }\nexport type OffersHomeQueryHookResult = ReturnType<typeof useOffersHomeQuery>;\nexport type OffersHomeLazyQueryHookResult = ReturnType<typeof useOffersHomeLazyQuery>;\nexport type OffersHomeSuspenseQueryHookResult = ReturnType<typeof useOffersHomeSuspenseQuery>;\nexport type OffersHomeQueryResult = Apollo.QueryResult<OffersHomeQuery, OffersHomeQueryVariables>;\nexport function refetchOffersHomeQuery(variables?: OffersHomeQueryVariables) {\n      return { query: OffersHomeDocument, variables: variables };\n    }\nexport const SendKudosDocument: TypedDocumentNode<SendKudosMutation, SendKudosMutationVariables> = gql`\n  mutation sendKudos($offerId: UUID!, $actionType: CleanString!, $selectedBadge: CleanString!, $userMessage: String!) {\n  sendKudos(\n    offerId: $offerId\n    actionType: $actionType\n    selectedBadge: $selectedBadge\n    userMessage: $userMessage\n  )\n}\n    `;\nexport type SendKudosMutationFn = Apollo.MutationFunction<SendKudosMutation, SendKudosMutationVariables>;\n\n/**\n * __useSendKudosMutation__\n *\n * To run a mutation, you first call `useSendKudosMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSendKudosMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [sendKudosMutation, { data, loading, error }] = useSendKudosMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      actionType: // value for 'actionType'\n *      selectedBadge: // value for 'selectedBadge'\n *      userMessage: // value for 'userMessage'\n *   },\n * });\n */\nexport function useSendKudosMutation(baseOptions?: Apollo.MutationHookOptions<SendKudosMutation, SendKudosMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SendKudosMutation, SendKudosMutationVariables>(SendKudosDocument, options);\n      }\nexport type SendKudosMutationHookResult = ReturnType<typeof useSendKudosMutation>;\nexport type SendKudosMutationResult = Apollo.MutationResult<SendKudosMutation>;\nexport type SendKudosMutationOptions = Apollo.BaseMutationOptions<SendKudosMutation, SendKudosMutationVariables>;\nexport const ForceUpdateSigningStatusDocument: TypedDocumentNode<ForceUpdateSigningStatusMutation, ForceUpdateSigningStatusMutationVariables> = gql`\n  mutation forceUpdateSigningStatus($document: DocumentCakeType!) {\n  forceUpdateSigningStatus(document: $document)\n}\n    `;\nexport type ForceUpdateSigningStatusMutationFn = Apollo.MutationFunction<ForceUpdateSigningStatusMutation, ForceUpdateSigningStatusMutationVariables>;\n\n/**\n * __useForceUpdateSigningStatusMutation__\n *\n * To run a mutation, you first call `useForceUpdateSigningStatusMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useForceUpdateSigningStatusMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [forceUpdateSigningStatusMutation, { data, loading, error }] = useForceUpdateSigningStatusMutation({\n *   variables: {\n *      document: // value for 'document'\n *   },\n * });\n */\nexport function useForceUpdateSigningStatusMutation(baseOptions?: Apollo.MutationHookOptions<ForceUpdateSigningStatusMutation, ForceUpdateSigningStatusMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ForceUpdateSigningStatusMutation, ForceUpdateSigningStatusMutationVariables>(ForceUpdateSigningStatusDocument, options);\n      }\nexport type ForceUpdateSigningStatusMutationHookResult = ReturnType<typeof useForceUpdateSigningStatusMutation>;\nexport type ForceUpdateSigningStatusMutationResult = Apollo.MutationResult<ForceUpdateSigningStatusMutation>;\nexport type ForceUpdateSigningStatusMutationOptions = Apollo.BaseMutationOptions<ForceUpdateSigningStatusMutation, ForceUpdateSigningStatusMutationVariables>;\nexport const OffersDetailsEsopDocument: TypedDocumentNode<OffersDetailsEsopQuery, OffersDetailsEsopQueryVariables> = gql`\n  query OffersDetailsEsop($offerId: UUID!) {\n  esopOffer(offerId: $offerId) {\n    id\n    created\n    modified\n    inviteDate\n    disclosurePeriodDays\n    shareholder {\n      id\n      displayName\n      avatar\n      trustAbn\n      heldInTrust\n      trustName\n      computedType\n      investorData {\n        name\n        email\n        phone\n        jointIndex\n        address {\n          line2\n          line1\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n        companyData {\n          contactPerson\n          identifierType\n          identifierNumber\n          signers {\n            name\n            email\n            role\n          }\n        }\n      }\n      recipient {\n        id\n        displayName\n        avatar\n        trustAbn\n        heldInTrust\n        trustName\n        computedType\n        investorData {\n          name\n          email\n          phone\n          jointIndex\n          address {\n            line2\n            line1\n            locality\n            administrativeArea1\n            postcode\n            country\n          }\n          companyData {\n            contactPerson\n            identifierType\n            identifierNumber\n            signers {\n              name\n              email\n              role\n            }\n          }\n        }\n      }\n    }\n    allowNomineeTrust\n    country\n    requireWitness\n    hasTransactions\n    vestStartDate\n    dateGranted\n    status\n    softStatus\n    optionPrice\n    exercisePrice\n    currency\n    optionType\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    offerLetter {\n      id\n      name\n      type\n      contractType\n      status\n      signatures {\n        email\n        status\n      }\n    }\n    planRules {\n      id\n      name\n      type\n      contractType\n      status\n    }\n    offerLetterTemplate {\n      id\n      name\n      type\n      contractType\n      status\n    }\n    planRulesTemplate {\n      id\n      name\n      type\n      contractType\n      status\n    }\n    vestingEvents {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: esoptransactionSet {\n        id\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n      }\n    }\n    group {\n      id\n      country\n      sharetype {\n        symbol\n      }\n      plan {\n        name\n        organisation {\n          id\n          type\n          name\n          logo: logoImageLink\n          currency\n          fullyDilutedShares\n          totalShares\n          totalSharesUnexercised\n          valuationVisibleToOptionholders\n          ownershipVisibleToOptionholders\n          valuationAt {\n            valuation\n          }\n        }\n        documents {\n          id\n          name\n          file\n        }\n      }\n      currency\n    }\n  }\n}\n    `;\n\n/**\n * __useOffersDetailsEsopQuery__\n *\n * To run a query within a React component, call `useOffersDetailsEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffersDetailsEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffersDetailsEsopQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useOffersDetailsEsopQuery(baseOptions: Apollo.QueryHookOptions<OffersDetailsEsopQuery, OffersDetailsEsopQueryVariables> & ({ variables: OffersDetailsEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffersDetailsEsopQuery, OffersDetailsEsopQueryVariables>(OffersDetailsEsopDocument, options);\n      }\nexport function useOffersDetailsEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffersDetailsEsopQuery, OffersDetailsEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffersDetailsEsopQuery, OffersDetailsEsopQueryVariables>(OffersDetailsEsopDocument, options);\n        }\nexport function useOffersDetailsEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffersDetailsEsopQuery, OffersDetailsEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffersDetailsEsopQuery, OffersDetailsEsopQueryVariables>(OffersDetailsEsopDocument, options);\n        }\nexport type OffersDetailsEsopQueryHookResult = ReturnType<typeof useOffersDetailsEsopQuery>;\nexport type OffersDetailsEsopLazyQueryHookResult = ReturnType<typeof useOffersDetailsEsopLazyQuery>;\nexport type OffersDetailsEsopSuspenseQueryHookResult = ReturnType<typeof useOffersDetailsEsopSuspenseQuery>;\nexport type OffersDetailsEsopQueryResult = Apollo.QueryResult<OffersDetailsEsopQuery, OffersDetailsEsopQueryVariables>;\nexport function refetchOffersDetailsEsopQuery(variables: OffersDetailsEsopQueryVariables) {\n      return { query: OffersDetailsEsopDocument, variables: variables };\n    }\nexport const ConfirmOfferInvestorDetailsEsopDocument: TypedDocumentNode<ConfirmOfferInvestorDetailsEsopMutation, ConfirmOfferInvestorDetailsEsopMutationVariables> = gql`\n  mutation confirmOfferInvestorDetailsEsop($offerId: EsopOfferCakeType!, $recipientData: ShareholderDataInput!, $trustData: ShareholderDataInput) {\n  confirmOfferInvestorDetailsEsop(\n    offer: $offerId\n    investorData: $recipientData\n    investorTrustData: $trustData\n  )\n}\n    `;\nexport type ConfirmOfferInvestorDetailsEsopMutationFn = Apollo.MutationFunction<ConfirmOfferInvestorDetailsEsopMutation, ConfirmOfferInvestorDetailsEsopMutationVariables>;\n\n/**\n * __useConfirmOfferInvestorDetailsEsopMutation__\n *\n * To run a mutation, you first call `useConfirmOfferInvestorDetailsEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useConfirmOfferInvestorDetailsEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [confirmOfferInvestorDetailsEsopMutation, { data, loading, error }] = useConfirmOfferInvestorDetailsEsopMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      recipientData: // value for 'recipientData'\n *      trustData: // value for 'trustData'\n *   },\n * });\n */\nexport function useConfirmOfferInvestorDetailsEsopMutation(baseOptions?: Apollo.MutationHookOptions<ConfirmOfferInvestorDetailsEsopMutation, ConfirmOfferInvestorDetailsEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ConfirmOfferInvestorDetailsEsopMutation, ConfirmOfferInvestorDetailsEsopMutationVariables>(ConfirmOfferInvestorDetailsEsopDocument, options);\n      }\nexport type ConfirmOfferInvestorDetailsEsopMutationHookResult = ReturnType<typeof useConfirmOfferInvestorDetailsEsopMutation>;\nexport type ConfirmOfferInvestorDetailsEsopMutationResult = Apollo.MutationResult<ConfirmOfferInvestorDetailsEsopMutation>;\nexport type ConfirmOfferInvestorDetailsEsopMutationOptions = Apollo.BaseMutationOptions<ConfirmOfferInvestorDetailsEsopMutation, ConfirmOfferInvestorDetailsEsopMutationVariables>;\nexport const DeclineOfferEsopDocument: TypedDocumentNode<DeclineOfferEsopMutation, DeclineOfferEsopMutationVariables> = gql`\n  mutation declineOfferEsop($esopOfferId: EsopOfferCakeType!) {\n  declineOfferEsop(offer: $esopOfferId)\n}\n    `;\nexport type DeclineOfferEsopMutationFn = Apollo.MutationFunction<DeclineOfferEsopMutation, DeclineOfferEsopMutationVariables>;\n\n/**\n * __useDeclineOfferEsopMutation__\n *\n * To run a mutation, you first call `useDeclineOfferEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeclineOfferEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [declineOfferEsopMutation, { data, loading, error }] = useDeclineOfferEsopMutation({\n *   variables: {\n *      esopOfferId: // value for 'esopOfferId'\n *   },\n * });\n */\nexport function useDeclineOfferEsopMutation(baseOptions?: Apollo.MutationHookOptions<DeclineOfferEsopMutation, DeclineOfferEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeclineOfferEsopMutation, DeclineOfferEsopMutationVariables>(DeclineOfferEsopDocument, options);\n      }\nexport type DeclineOfferEsopMutationHookResult = ReturnType<typeof useDeclineOfferEsopMutation>;\nexport type DeclineOfferEsopMutationResult = Apollo.MutationResult<DeclineOfferEsopMutation>;\nexport type DeclineOfferEsopMutationOptions = Apollo.BaseMutationOptions<DeclineOfferEsopMutation, DeclineOfferEsopMutationVariables>;\nexport const SignOfferLetterEsopDocument: TypedDocumentNode<SignOfferLetterEsopMutation, SignOfferLetterEsopMutationVariables> = gql`\n  mutation signOfferLetterEsop($offerId: EsopOfferCakeType!, $witness: WitnessInputType) {\n  signOfferLetterEsop(offer: $offerId, witness: $witness) {\n    urlList\n    signatureRequestId\n    expectedCallbackUrl\n  }\n}\n    `;\nexport type SignOfferLetterEsopMutationFn = Apollo.MutationFunction<SignOfferLetterEsopMutation, SignOfferLetterEsopMutationVariables>;\n\n/**\n * __useSignOfferLetterEsopMutation__\n *\n * To run a mutation, you first call `useSignOfferLetterEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSignOfferLetterEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [signOfferLetterEsopMutation, { data, loading, error }] = useSignOfferLetterEsopMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      witness: // value for 'witness'\n *   },\n * });\n */\nexport function useSignOfferLetterEsopMutation(baseOptions?: Apollo.MutationHookOptions<SignOfferLetterEsopMutation, SignOfferLetterEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SignOfferLetterEsopMutation, SignOfferLetterEsopMutationVariables>(SignOfferLetterEsopDocument, options);\n      }\nexport type SignOfferLetterEsopMutationHookResult = ReturnType<typeof useSignOfferLetterEsopMutation>;\nexport type SignOfferLetterEsopMutationResult = Apollo.MutationResult<SignOfferLetterEsopMutation>;\nexport type SignOfferLetterEsopMutationOptions = Apollo.BaseMutationOptions<SignOfferLetterEsopMutation, SignOfferLetterEsopMutationVariables>;\nexport const OffersDetailsEssDocument: TypedDocumentNode<OffersDetailsEssQuery, OffersDetailsEssQueryVariables> = gql`\n  query OffersDetailsEss($offerId: UUID!) {\n  essOffer(offerId: $offerId) {\n    id\n    created\n    modified\n    inviteDate\n    disclosurePeriodDays\n    group {\n      id\n      country\n      sharetype {\n        symbol\n      }\n      plan {\n        name\n        organisation {\n          id\n          type\n          name\n          logo: logoImageLink\n          currency\n          fullyDilutedShares\n          totalShares\n          totalSharesUnexercised\n          valuationVisibleToShareholders\n          ownershipVisibleToShareholders\n          valuationAt {\n            valuation\n          }\n        }\n        documents {\n          id\n          name\n          file\n        }\n      }\n    }\n    shareholder {\n      id\n      displayName\n      avatar\n      trustAbn\n      heldInTrust\n      trustName\n      computedType\n      organisation {\n        type\n      }\n      investorData {\n        name\n        email\n        phone\n        jointIndex\n        address {\n          line2\n          line1\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n        companyData {\n          contactPerson\n          identifierType\n          identifierNumber\n          signers {\n            name\n            email\n            role\n          }\n        }\n      }\n      recipient {\n        id\n        displayName\n        avatar\n        trustAbn\n        heldInTrust\n        trustName\n        computedType\n        investorData {\n          name\n          email\n          phone\n          jointIndex\n          address {\n            line2\n            line1\n            locality\n            administrativeArea1\n            postcode\n            country\n          }\n          companyData {\n            contactPerson\n            identifierType\n            identifierNumber\n            signers {\n              name\n              email\n              role\n            }\n          }\n        }\n      }\n    }\n    allowNomineeTrust\n    country\n    requireWitness\n    hasTransactions\n    vestStartDate\n    sharePrice\n    loanFunded\n    dateGranted\n    status\n    softStatus\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    offerLetter {\n      id\n      name\n      type\n      contractType\n      status\n      signatures {\n        email\n        status\n      }\n    }\n    planRules {\n      id\n      name\n      type\n      contractType\n      status\n    }\n    offerLetterTemplate {\n      id\n      name\n      type\n      contractType\n      status\n    }\n    planRulesTemplate {\n      id\n      name\n      type\n      contractType\n      status\n    }\n    vestingEvents {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: esstransactionSet {\n        id\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useOffersDetailsEssQuery__\n *\n * To run a query within a React component, call `useOffersDetailsEssQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffersDetailsEssQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffersDetailsEssQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useOffersDetailsEssQuery(baseOptions: Apollo.QueryHookOptions<OffersDetailsEssQuery, OffersDetailsEssQueryVariables> & ({ variables: OffersDetailsEssQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffersDetailsEssQuery, OffersDetailsEssQueryVariables>(OffersDetailsEssDocument, options);\n      }\nexport function useOffersDetailsEssLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffersDetailsEssQuery, OffersDetailsEssQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffersDetailsEssQuery, OffersDetailsEssQueryVariables>(OffersDetailsEssDocument, options);\n        }\nexport function useOffersDetailsEssSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffersDetailsEssQuery, OffersDetailsEssQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffersDetailsEssQuery, OffersDetailsEssQueryVariables>(OffersDetailsEssDocument, options);\n        }\nexport type OffersDetailsEssQueryHookResult = ReturnType<typeof useOffersDetailsEssQuery>;\nexport type OffersDetailsEssLazyQueryHookResult = ReturnType<typeof useOffersDetailsEssLazyQuery>;\nexport type OffersDetailsEssSuspenseQueryHookResult = ReturnType<typeof useOffersDetailsEssSuspenseQuery>;\nexport type OffersDetailsEssQueryResult = Apollo.QueryResult<OffersDetailsEssQuery, OffersDetailsEssQueryVariables>;\nexport function refetchOffersDetailsEssQuery(variables: OffersDetailsEssQueryVariables) {\n      return { query: OffersDetailsEssDocument, variables: variables };\n    }\nexport const ConfirmOfferInvestorDetailsEssDocument: TypedDocumentNode<ConfirmOfferInvestorDetailsEssMutation, ConfirmOfferInvestorDetailsEssMutationVariables> = gql`\n  mutation confirmOfferInvestorDetailsEss($offerId: EssOfferCakeType!, $recipientData: ShareholderDataInput!, $trustData: ShareholderDataInput) {\n  confirmOfferInvestorDetailsEss(\n    offer: $offerId\n    investorData: $recipientData\n    investorTrustData: $trustData\n  )\n}\n    `;\nexport type ConfirmOfferInvestorDetailsEssMutationFn = Apollo.MutationFunction<ConfirmOfferInvestorDetailsEssMutation, ConfirmOfferInvestorDetailsEssMutationVariables>;\n\n/**\n * __useConfirmOfferInvestorDetailsEssMutation__\n *\n * To run a mutation, you first call `useConfirmOfferInvestorDetailsEssMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useConfirmOfferInvestorDetailsEssMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [confirmOfferInvestorDetailsEssMutation, { data, loading, error }] = useConfirmOfferInvestorDetailsEssMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      recipientData: // value for 'recipientData'\n *      trustData: // value for 'trustData'\n *   },\n * });\n */\nexport function useConfirmOfferInvestorDetailsEssMutation(baseOptions?: Apollo.MutationHookOptions<ConfirmOfferInvestorDetailsEssMutation, ConfirmOfferInvestorDetailsEssMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ConfirmOfferInvestorDetailsEssMutation, ConfirmOfferInvestorDetailsEssMutationVariables>(ConfirmOfferInvestorDetailsEssDocument, options);\n      }\nexport type ConfirmOfferInvestorDetailsEssMutationHookResult = ReturnType<typeof useConfirmOfferInvestorDetailsEssMutation>;\nexport type ConfirmOfferInvestorDetailsEssMutationResult = Apollo.MutationResult<ConfirmOfferInvestorDetailsEssMutation>;\nexport type ConfirmOfferInvestorDetailsEssMutationOptions = Apollo.BaseMutationOptions<ConfirmOfferInvestorDetailsEssMutation, ConfirmOfferInvestorDetailsEssMutationVariables>;\nexport const DeclineOfferEssDocument: TypedDocumentNode<DeclineOfferEssMutation, DeclineOfferEssMutationVariables> = gql`\n  mutation declineOfferEss($essOfferId: EssOfferCakeType!) {\n  declineOfferEss(offer: $essOfferId)\n}\n    `;\nexport type DeclineOfferEssMutationFn = Apollo.MutationFunction<DeclineOfferEssMutation, DeclineOfferEssMutationVariables>;\n\n/**\n * __useDeclineOfferEssMutation__\n *\n * To run a mutation, you first call `useDeclineOfferEssMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeclineOfferEssMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [declineOfferEssMutation, { data, loading, error }] = useDeclineOfferEssMutation({\n *   variables: {\n *      essOfferId: // value for 'essOfferId'\n *   },\n * });\n */\nexport function useDeclineOfferEssMutation(baseOptions?: Apollo.MutationHookOptions<DeclineOfferEssMutation, DeclineOfferEssMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeclineOfferEssMutation, DeclineOfferEssMutationVariables>(DeclineOfferEssDocument, options);\n      }\nexport type DeclineOfferEssMutationHookResult = ReturnType<typeof useDeclineOfferEssMutation>;\nexport type DeclineOfferEssMutationResult = Apollo.MutationResult<DeclineOfferEssMutation>;\nexport type DeclineOfferEssMutationOptions = Apollo.BaseMutationOptions<DeclineOfferEssMutation, DeclineOfferEssMutationVariables>;\nexport const SignOfferLetterEssDocument: TypedDocumentNode<SignOfferLetterEssMutation, SignOfferLetterEssMutationVariables> = gql`\n  mutation signOfferLetterEss($offerId: EssOfferCakeType!, $witness: WitnessInputType) {\n  signOfferLetterEss(offer: $offerId, witness: $witness) {\n    urlList\n    signatureRequestId\n    expectedCallbackUrl\n  }\n}\n    `;\nexport type SignOfferLetterEssMutationFn = Apollo.MutationFunction<SignOfferLetterEssMutation, SignOfferLetterEssMutationVariables>;\n\n/**\n * __useSignOfferLetterEssMutation__\n *\n * To run a mutation, you first call `useSignOfferLetterEssMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSignOfferLetterEssMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [signOfferLetterEssMutation, { data, loading, error }] = useSignOfferLetterEssMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      witness: // value for 'witness'\n *   },\n * });\n */\nexport function useSignOfferLetterEssMutation(baseOptions?: Apollo.MutationHookOptions<SignOfferLetterEssMutation, SignOfferLetterEssMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SignOfferLetterEssMutation, SignOfferLetterEssMutationVariables>(SignOfferLetterEssDocument, options);\n      }\nexport type SignOfferLetterEssMutationHookResult = ReturnType<typeof useSignOfferLetterEssMutation>;\nexport type SignOfferLetterEssMutationResult = Apollo.MutationResult<SignOfferLetterEssMutation>;\nexport type SignOfferLetterEssMutationOptions = Apollo.BaseMutationOptions<SignOfferLetterEssMutation, SignOfferLetterEssMutationVariables>;\nexport const OffersDetailsRaiseEquityDocument: TypedDocumentNode<OffersDetailsRaiseEquityQuery, OffersDetailsRaiseEquityQueryVariables> = gql`\n  query OffersDetailsRaiseEquity($offerId: OrganisationRaiseOfferCakeType!) {\n  investorEquityOffer(offer: $offerId) {\n    id\n    organisationRaise {\n      name\n      valuation\n      existingShares\n      raiseGoalAmount\n      endDate\n      shareType {\n        name\n      }\n      documents {\n        id\n        name\n        extension\n        created\n        type\n      }\n      organisation {\n        id\n        id\n        name\n        logo\n        country\n        currency\n        valuationVisibleToShareholders\n        ownershipVisibleToShareholders\n      }\n      contractTemplate {\n        id\n        name\n        extension\n        contractType\n        contractProvider\n        status\n      }\n      payment {\n        ... on AuPaymentDetailsType {\n          __typename\n          accountName\n          accountNumber\n          bsb\n          reference\n          isTrustAccount\n        }\n        ... on SgPaymentDetailsType {\n          __typename\n          accountName\n          accountNumber\n          swiftCode\n          bankCode\n          branchCode\n        }\n        ... on FallbackPaymentDetailsType {\n          __typename\n          details\n        }\n      }\n    }\n    shareholder {\n      id\n      displayName\n      avatar\n      trustAbn\n      heldInTrust\n      trustName\n      computedType\n      investorData {\n        name\n        email\n        phone\n        jointIndex\n        address {\n          line2\n          line1\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n        companyData {\n          contactPerson\n          identifierType\n          identifierNumber\n          signers {\n            name\n            email\n            role\n          }\n        }\n      }\n      recipient {\n        id\n        displayName\n        avatar\n        trustAbn\n        heldInTrust\n        trustName\n        computedType\n        investorData {\n          name\n          email\n          phone\n          jointIndex\n          address {\n            line2\n            line1\n            locality\n            administrativeArea1\n            postcode\n            country\n          }\n          companyData {\n            contactPerson\n            identifierType\n            identifierNumber\n            signers {\n              name\n              email\n              role\n            }\n          }\n        }\n      }\n    }\n    amount\n    status\n    contract {\n      id\n      name\n      created\n      extension\n      contractType\n      signatures {\n        name\n        email\n        status\n        extra\n      }\n    }\n    requireWitness\n  }\n}\n    `;\n\n/**\n * __useOffersDetailsRaiseEquityQuery__\n *\n * To run a query within a React component, call `useOffersDetailsRaiseEquityQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffersDetailsRaiseEquityQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffersDetailsRaiseEquityQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useOffersDetailsRaiseEquityQuery(baseOptions: Apollo.QueryHookOptions<OffersDetailsRaiseEquityQuery, OffersDetailsRaiseEquityQueryVariables> & ({ variables: OffersDetailsRaiseEquityQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffersDetailsRaiseEquityQuery, OffersDetailsRaiseEquityQueryVariables>(OffersDetailsRaiseEquityDocument, options);\n      }\nexport function useOffersDetailsRaiseEquityLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffersDetailsRaiseEquityQuery, OffersDetailsRaiseEquityQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffersDetailsRaiseEquityQuery, OffersDetailsRaiseEquityQueryVariables>(OffersDetailsRaiseEquityDocument, options);\n        }\nexport function useOffersDetailsRaiseEquitySuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffersDetailsRaiseEquityQuery, OffersDetailsRaiseEquityQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffersDetailsRaiseEquityQuery, OffersDetailsRaiseEquityQueryVariables>(OffersDetailsRaiseEquityDocument, options);\n        }\nexport type OffersDetailsRaiseEquityQueryHookResult = ReturnType<typeof useOffersDetailsRaiseEquityQuery>;\nexport type OffersDetailsRaiseEquityLazyQueryHookResult = ReturnType<typeof useOffersDetailsRaiseEquityLazyQuery>;\nexport type OffersDetailsRaiseEquitySuspenseQueryHookResult = ReturnType<typeof useOffersDetailsRaiseEquitySuspenseQuery>;\nexport type OffersDetailsRaiseEquityQueryResult = Apollo.QueryResult<OffersDetailsRaiseEquityQuery, OffersDetailsRaiseEquityQueryVariables>;\nexport function refetchOffersDetailsRaiseEquityQuery(variables: OffersDetailsRaiseEquityQueryVariables) {\n      return { query: OffersDetailsRaiseEquityDocument, variables: variables };\n    }\nexport const ConfirmEquityOfferInvestorDetailsDocument: TypedDocumentNode<ConfirmEquityOfferInvestorDetailsMutation, ConfirmEquityOfferInvestorDetailsMutationVariables> = gql`\n  mutation confirmEquityOfferInvestorDetails($offerId: OrganisationRaiseOfferCakeType!, $shareholderData: ShareholderDataInput!) {\n  confirmEquityOfferInvestorDetails(\n    offer: $offerId\n    investorData: $shareholderData\n  ) {\n    ok\n  }\n}\n    `;\nexport type ConfirmEquityOfferInvestorDetailsMutationFn = Apollo.MutationFunction<ConfirmEquityOfferInvestorDetailsMutation, ConfirmEquityOfferInvestorDetailsMutationVariables>;\n\n/**\n * __useConfirmEquityOfferInvestorDetailsMutation__\n *\n * To run a mutation, you first call `useConfirmEquityOfferInvestorDetailsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useConfirmEquityOfferInvestorDetailsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [confirmEquityOfferInvestorDetailsMutation, { data, loading, error }] = useConfirmEquityOfferInvestorDetailsMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      shareholderData: // value for 'shareholderData'\n *   },\n * });\n */\nexport function useConfirmEquityOfferInvestorDetailsMutation(baseOptions?: Apollo.MutationHookOptions<ConfirmEquityOfferInvestorDetailsMutation, ConfirmEquityOfferInvestorDetailsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ConfirmEquityOfferInvestorDetailsMutation, ConfirmEquityOfferInvestorDetailsMutationVariables>(ConfirmEquityOfferInvestorDetailsDocument, options);\n      }\nexport type ConfirmEquityOfferInvestorDetailsMutationHookResult = ReturnType<typeof useConfirmEquityOfferInvestorDetailsMutation>;\nexport type ConfirmEquityOfferInvestorDetailsMutationResult = Apollo.MutationResult<ConfirmEquityOfferInvestorDetailsMutation>;\nexport type ConfirmEquityOfferInvestorDetailsMutationOptions = Apollo.BaseMutationOptions<ConfirmEquityOfferInvestorDetailsMutation, ConfirmEquityOfferInvestorDetailsMutationVariables>;\nexport const DeclineEquityOfferDocument: TypedDocumentNode<DeclineEquityOfferMutation, DeclineEquityOfferMutationVariables> = gql`\n  mutation declineEquityOffer($equityOfferId: OrganisationRaiseOfferCakeType!) {\n  declineEquityOffer(offer: $equityOfferId) {\n    ok\n  }\n}\n    `;\nexport type DeclineEquityOfferMutationFn = Apollo.MutationFunction<DeclineEquityOfferMutation, DeclineEquityOfferMutationVariables>;\n\n/**\n * __useDeclineEquityOfferMutation__\n *\n * To run a mutation, you first call `useDeclineEquityOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeclineEquityOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [declineEquityOfferMutation, { data, loading, error }] = useDeclineEquityOfferMutation({\n *   variables: {\n *      equityOfferId: // value for 'equityOfferId'\n *   },\n * });\n */\nexport function useDeclineEquityOfferMutation(baseOptions?: Apollo.MutationHookOptions<DeclineEquityOfferMutation, DeclineEquityOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeclineEquityOfferMutation, DeclineEquityOfferMutationVariables>(DeclineEquityOfferDocument, options);\n      }\nexport type DeclineEquityOfferMutationHookResult = ReturnType<typeof useDeclineEquityOfferMutation>;\nexport type DeclineEquityOfferMutationResult = Apollo.MutationResult<DeclineEquityOfferMutation>;\nexport type DeclineEquityOfferMutationOptions = Apollo.BaseMutationOptions<DeclineEquityOfferMutation, DeclineEquityOfferMutationVariables>;\nexport const AcceptEquityOfferDocument: TypedDocumentNode<AcceptEquityOfferMutation, AcceptEquityOfferMutationVariables> = gql`\n  mutation acceptEquityOffer($equityOfferId: OrganisationRaiseOfferCakeType!, $amount: CakeDecimal!) {\n  acceptEquityOffer(offer: $equityOfferId, amount: $amount) {\n    ok\n  }\n}\n    `;\nexport type AcceptEquityOfferMutationFn = Apollo.MutationFunction<AcceptEquityOfferMutation, AcceptEquityOfferMutationVariables>;\n\n/**\n * __useAcceptEquityOfferMutation__\n *\n * To run a mutation, you first call `useAcceptEquityOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAcceptEquityOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [acceptEquityOfferMutation, { data, loading, error }] = useAcceptEquityOfferMutation({\n *   variables: {\n *      equityOfferId: // value for 'equityOfferId'\n *      amount: // value for 'amount'\n *   },\n * });\n */\nexport function useAcceptEquityOfferMutation(baseOptions?: Apollo.MutationHookOptions<AcceptEquityOfferMutation, AcceptEquityOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AcceptEquityOfferMutation, AcceptEquityOfferMutationVariables>(AcceptEquityOfferDocument, options);\n      }\nexport type AcceptEquityOfferMutationHookResult = ReturnType<typeof useAcceptEquityOfferMutation>;\nexport type AcceptEquityOfferMutationResult = Apollo.MutationResult<AcceptEquityOfferMutation>;\nexport type AcceptEquityOfferMutationOptions = Apollo.BaseMutationOptions<AcceptEquityOfferMutation, AcceptEquityOfferMutationVariables>;\nexport const SignSubscriptionAgreementDocument: TypedDocumentNode<SignSubscriptionAgreementMutation, SignSubscriptionAgreementMutationVariables> = gql`\n  mutation signSubscriptionAgreement($offerId: OrganisationRaiseOfferCakeType!, $witness: WitnessInputType) {\n  signSubscriptionAgreement(offer: $offerId, witness: $witness) {\n    urlList\n    signatureRequestId\n    expectedCallbackUrl\n  }\n}\n    `;\nexport type SignSubscriptionAgreementMutationFn = Apollo.MutationFunction<SignSubscriptionAgreementMutation, SignSubscriptionAgreementMutationVariables>;\n\n/**\n * __useSignSubscriptionAgreementMutation__\n *\n * To run a mutation, you first call `useSignSubscriptionAgreementMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSignSubscriptionAgreementMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [signSubscriptionAgreementMutation, { data, loading, error }] = useSignSubscriptionAgreementMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      witness: // value for 'witness'\n *   },\n * });\n */\nexport function useSignSubscriptionAgreementMutation(baseOptions?: Apollo.MutationHookOptions<SignSubscriptionAgreementMutation, SignSubscriptionAgreementMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SignSubscriptionAgreementMutation, SignSubscriptionAgreementMutationVariables>(SignSubscriptionAgreementDocument, options);\n      }\nexport type SignSubscriptionAgreementMutationHookResult = ReturnType<typeof useSignSubscriptionAgreementMutation>;\nexport type SignSubscriptionAgreementMutationResult = Apollo.MutationResult<SignSubscriptionAgreementMutation>;\nexport type SignSubscriptionAgreementMutationOptions = Apollo.BaseMutationOptions<SignSubscriptionAgreementMutation, SignSubscriptionAgreementMutationVariables>;\nexport const OffersDetailsRaiseNotesDocument: TypedDocumentNode<OffersDetailsRaiseNotesQuery, OffersDetailsRaiseNotesQueryVariables> = gql`\n  query OffersDetailsRaiseNotes($offerId: NotesRoundOfferCakeType!) {\n  investorNoteOffer(offer: $offerId) {\n    id\n    principal\n    status\n    valuationCap\n    discountRate\n    interestRate\n    maturityDate\n    payment {\n      ... on AuPaymentDetailsType {\n        accountName\n        accountNumber\n        bsb\n        reference\n        isTrustAccount\n      }\n      ... on SgPaymentDetailsType {\n        accountName\n        accountNumber\n        swiftCode\n        bankCode\n        branchCode\n      }\n      ... on FallbackPaymentDetailsType {\n        details\n      }\n    }\n    noteType\n    notesRound {\n      name\n      documents {\n        id\n        name\n        extension\n        created\n        type\n      }\n      organisation {\n        id\n        name\n        logo\n        country\n        currency\n      }\n    }\n    shareholder {\n      id\n      displayName\n      avatar\n      trustAbn\n      heldInTrust\n      trustName\n      computedType\n      investorData {\n        name\n        email\n        phone\n        jointIndex\n        address {\n          line2\n          line1\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n        companyData {\n          contactPerson\n          identifierType\n          identifierNumber\n          signers {\n            name\n            email\n            role\n          }\n        }\n      }\n      recipient {\n        id\n        displayName\n        avatar\n        trustAbn\n        heldInTrust\n        trustName\n        computedType\n        investorData {\n          name\n          email\n          phone\n          jointIndex\n          address {\n            line2\n            line1\n            locality\n            administrativeArea1\n            postcode\n            country\n          }\n          companyData {\n            contactPerson\n            identifierType\n            identifierNumber\n            signers {\n              name\n              email\n              role\n            }\n          }\n        }\n      }\n    }\n    contract {\n      id\n      created\n      name\n      extension\n      created\n      contractType\n      signatures {\n        name\n        email\n        status\n      }\n    }\n    requireWitness\n  }\n}\n    `;\n\n/**\n * __useOffersDetailsRaiseNotesQuery__\n *\n * To run a query within a React component, call `useOffersDetailsRaiseNotesQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffersDetailsRaiseNotesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffersDetailsRaiseNotesQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useOffersDetailsRaiseNotesQuery(baseOptions: Apollo.QueryHookOptions<OffersDetailsRaiseNotesQuery, OffersDetailsRaiseNotesQueryVariables> & ({ variables: OffersDetailsRaiseNotesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffersDetailsRaiseNotesQuery, OffersDetailsRaiseNotesQueryVariables>(OffersDetailsRaiseNotesDocument, options);\n      }\nexport function useOffersDetailsRaiseNotesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffersDetailsRaiseNotesQuery, OffersDetailsRaiseNotesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffersDetailsRaiseNotesQuery, OffersDetailsRaiseNotesQueryVariables>(OffersDetailsRaiseNotesDocument, options);\n        }\nexport function useOffersDetailsRaiseNotesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffersDetailsRaiseNotesQuery, OffersDetailsRaiseNotesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffersDetailsRaiseNotesQuery, OffersDetailsRaiseNotesQueryVariables>(OffersDetailsRaiseNotesDocument, options);\n        }\nexport type OffersDetailsRaiseNotesQueryHookResult = ReturnType<typeof useOffersDetailsRaiseNotesQuery>;\nexport type OffersDetailsRaiseNotesLazyQueryHookResult = ReturnType<typeof useOffersDetailsRaiseNotesLazyQuery>;\nexport type OffersDetailsRaiseNotesSuspenseQueryHookResult = ReturnType<typeof useOffersDetailsRaiseNotesSuspenseQuery>;\nexport type OffersDetailsRaiseNotesQueryResult = Apollo.QueryResult<OffersDetailsRaiseNotesQuery, OffersDetailsRaiseNotesQueryVariables>;\nexport function refetchOffersDetailsRaiseNotesQuery(variables: OffersDetailsRaiseNotesQueryVariables) {\n      return { query: OffersDetailsRaiseNotesDocument, variables: variables };\n    }\nexport const ConfirmNotesOfferInvestorDetailsDocument: TypedDocumentNode<ConfirmNotesOfferInvestorDetailsMutation, ConfirmNotesOfferInvestorDetailsMutationVariables> = gql`\n  mutation confirmNotesOfferInvestorDetails($offerId: NotesRoundOfferCakeType!, $shareholderData: ShareholderDataInput!) {\n  confirmNotesOfferInvestorDetails(\n    offer: $offerId\n    investorData: $shareholderData\n  ) {\n    ok\n  }\n}\n    `;\nexport type ConfirmNotesOfferInvestorDetailsMutationFn = Apollo.MutationFunction<ConfirmNotesOfferInvestorDetailsMutation, ConfirmNotesOfferInvestorDetailsMutationVariables>;\n\n/**\n * __useConfirmNotesOfferInvestorDetailsMutation__\n *\n * To run a mutation, you first call `useConfirmNotesOfferInvestorDetailsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useConfirmNotesOfferInvestorDetailsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [confirmNotesOfferInvestorDetailsMutation, { data, loading, error }] = useConfirmNotesOfferInvestorDetailsMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      shareholderData: // value for 'shareholderData'\n *   },\n * });\n */\nexport function useConfirmNotesOfferInvestorDetailsMutation(baseOptions?: Apollo.MutationHookOptions<ConfirmNotesOfferInvestorDetailsMutation, ConfirmNotesOfferInvestorDetailsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ConfirmNotesOfferInvestorDetailsMutation, ConfirmNotesOfferInvestorDetailsMutationVariables>(ConfirmNotesOfferInvestorDetailsDocument, options);\n      }\nexport type ConfirmNotesOfferInvestorDetailsMutationHookResult = ReturnType<typeof useConfirmNotesOfferInvestorDetailsMutation>;\nexport type ConfirmNotesOfferInvestorDetailsMutationResult = Apollo.MutationResult<ConfirmNotesOfferInvestorDetailsMutation>;\nexport type ConfirmNotesOfferInvestorDetailsMutationOptions = Apollo.BaseMutationOptions<ConfirmNotesOfferInvestorDetailsMutation, ConfirmNotesOfferInvestorDetailsMutationVariables>;\nexport const DeclineNotesOfferDocument: TypedDocumentNode<DeclineNotesOfferMutation, DeclineNotesOfferMutationVariables> = gql`\n  mutation declineNotesOffer($notesOfferId: NotesRoundOfferCakeType!) {\n  declineNotesOffer(offer: $notesOfferId) {\n    ok\n  }\n}\n    `;\nexport type DeclineNotesOfferMutationFn = Apollo.MutationFunction<DeclineNotesOfferMutation, DeclineNotesOfferMutationVariables>;\n\n/**\n * __useDeclineNotesOfferMutation__\n *\n * To run a mutation, you first call `useDeclineNotesOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeclineNotesOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [declineNotesOfferMutation, { data, loading, error }] = useDeclineNotesOfferMutation({\n *   variables: {\n *      notesOfferId: // value for 'notesOfferId'\n *   },\n * });\n */\nexport function useDeclineNotesOfferMutation(baseOptions?: Apollo.MutationHookOptions<DeclineNotesOfferMutation, DeclineNotesOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeclineNotesOfferMutation, DeclineNotesOfferMutationVariables>(DeclineNotesOfferDocument, options);\n      }\nexport type DeclineNotesOfferMutationHookResult = ReturnType<typeof useDeclineNotesOfferMutation>;\nexport type DeclineNotesOfferMutationResult = Apollo.MutationResult<DeclineNotesOfferMutation>;\nexport type DeclineNotesOfferMutationOptions = Apollo.BaseMutationOptions<DeclineNotesOfferMutation, DeclineNotesOfferMutationVariables>;\nexport const AcceptNotesOfferDocument: TypedDocumentNode<AcceptNotesOfferMutation, AcceptNotesOfferMutationVariables> = gql`\n  mutation acceptNotesOffer($notesOfferId: NotesRoundOfferCakeType!, $principal: CakeDecimal) {\n  acceptNotesOffer(offer: $notesOfferId, principal: $principal) {\n    ok\n  }\n}\n    `;\nexport type AcceptNotesOfferMutationFn = Apollo.MutationFunction<AcceptNotesOfferMutation, AcceptNotesOfferMutationVariables>;\n\n/**\n * __useAcceptNotesOfferMutation__\n *\n * To run a mutation, you first call `useAcceptNotesOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAcceptNotesOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [acceptNotesOfferMutation, { data, loading, error }] = useAcceptNotesOfferMutation({\n *   variables: {\n *      notesOfferId: // value for 'notesOfferId'\n *      principal: // value for 'principal'\n *   },\n * });\n */\nexport function useAcceptNotesOfferMutation(baseOptions?: Apollo.MutationHookOptions<AcceptNotesOfferMutation, AcceptNotesOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AcceptNotesOfferMutation, AcceptNotesOfferMutationVariables>(AcceptNotesOfferDocument, options);\n      }\nexport type AcceptNotesOfferMutationHookResult = ReturnType<typeof useAcceptNotesOfferMutation>;\nexport type AcceptNotesOfferMutationResult = Apollo.MutationResult<AcceptNotesOfferMutation>;\nexport type AcceptNotesOfferMutationOptions = Apollo.BaseMutationOptions<AcceptNotesOfferMutation, AcceptNotesOfferMutationVariables>;\nexport const SignNoteAgreementDocument: TypedDocumentNode<SignNoteAgreementMutation, SignNoteAgreementMutationVariables> = gql`\n  mutation signNoteAgreement($offerId: NotesRoundOfferCakeType!, $witness: WitnessInputType) {\n  signNoteAgreement(offer: $offerId, witness: $witness) {\n    urlList\n    signatureRequestId\n    expectedCallbackUrl\n  }\n}\n    `;\nexport type SignNoteAgreementMutationFn = Apollo.MutationFunction<SignNoteAgreementMutation, SignNoteAgreementMutationVariables>;\n\n/**\n * __useSignNoteAgreementMutation__\n *\n * To run a mutation, you first call `useSignNoteAgreementMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSignNoteAgreementMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [signNoteAgreementMutation, { data, loading, error }] = useSignNoteAgreementMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      witness: // value for 'witness'\n *   },\n * });\n */\nexport function useSignNoteAgreementMutation(baseOptions?: Apollo.MutationHookOptions<SignNoteAgreementMutation, SignNoteAgreementMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SignNoteAgreementMutation, SignNoteAgreementMutationVariables>(SignNoteAgreementDocument, options);\n      }\nexport type SignNoteAgreementMutationHookResult = ReturnType<typeof useSignNoteAgreementMutation>;\nexport type SignNoteAgreementMutationResult = Apollo.MutationResult<SignNoteAgreementMutation>;\nexport type SignNoteAgreementMutationOptions = Apollo.BaseMutationOptions<SignNoteAgreementMutation, SignNoteAgreementMutationVariables>;\nexport const OffersDetailsRsuDocument: TypedDocumentNode<OffersDetailsRsuQuery, OffersDetailsRsuQueryVariables> = gql`\n  query OffersDetailsRsu($offerId: UUID!) {\n  rsuOffer(offerId: $offerId) {\n    id\n    created\n    modified\n    inviteDate\n    disclosurePeriodDays\n    group {\n      id\n      country\n      sharetype {\n        symbol\n      }\n      plan {\n        name\n        organisation {\n          id\n          type\n          name\n          logo: logoImageLink\n          currency\n          fullyDilutedShares\n          totalShares\n          totalSharesUnexercised\n          valuationVisibleToShareholders\n          ownershipVisibleToShareholders\n          valuationAt {\n            valuation\n          }\n        }\n        documents {\n          id\n          name\n          file\n        }\n      }\n    }\n    shareholder {\n      id\n      displayName\n      avatar\n      trustAbn\n      heldInTrust\n      trustName\n      computedType\n      investorData {\n        name\n        email\n        phone\n        jointIndex\n        address {\n          line2\n          line1\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n        companyData {\n          contactPerson\n          identifierType\n          identifierNumber\n          signers {\n            name\n            email\n            role\n          }\n        }\n      }\n      recipient {\n        id\n        displayName\n        avatar\n        trustAbn\n        heldInTrust\n        trustName\n        computedType\n        investorData {\n          name\n          email\n          phone\n          jointIndex\n          address {\n            line2\n            line1\n            locality\n            administrativeArea1\n            postcode\n            country\n          }\n          companyData {\n            contactPerson\n            identifierType\n            identifierNumber\n            signers {\n              name\n              email\n              role\n            }\n          }\n        }\n      }\n    }\n    allowNomineeTrust\n    country\n    requireWitness\n    hasTransactions\n    vestStartDate\n    dateGranted\n    status\n    softStatus\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    offerLetter {\n      id\n      name\n      type\n      contractType\n      status\n      signatures {\n        email\n        status\n      }\n    }\n    planRules {\n      id\n      name\n      type\n      contractType\n      status\n    }\n    offerLetterTemplate {\n      id\n      name\n      type\n      contractType\n      status\n    }\n    planRulesTemplate {\n      id\n      name\n      type\n      contractType\n      status\n    }\n    vestingEvents {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: rsutransactionSet {\n        id\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n      }\n    }\n    conversionlockevent: rsuconversionlockevent {\n      description\n    }\n  }\n}\n    `;\n\n/**\n * __useOffersDetailsRsuQuery__\n *\n * To run a query within a React component, call `useOffersDetailsRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffersDetailsRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffersDetailsRsuQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useOffersDetailsRsuQuery(baseOptions: Apollo.QueryHookOptions<OffersDetailsRsuQuery, OffersDetailsRsuQueryVariables> & ({ variables: OffersDetailsRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffersDetailsRsuQuery, OffersDetailsRsuQueryVariables>(OffersDetailsRsuDocument, options);\n      }\nexport function useOffersDetailsRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffersDetailsRsuQuery, OffersDetailsRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffersDetailsRsuQuery, OffersDetailsRsuQueryVariables>(OffersDetailsRsuDocument, options);\n        }\nexport function useOffersDetailsRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffersDetailsRsuQuery, OffersDetailsRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffersDetailsRsuQuery, OffersDetailsRsuQueryVariables>(OffersDetailsRsuDocument, options);\n        }\nexport type OffersDetailsRsuQueryHookResult = ReturnType<typeof useOffersDetailsRsuQuery>;\nexport type OffersDetailsRsuLazyQueryHookResult = ReturnType<typeof useOffersDetailsRsuLazyQuery>;\nexport type OffersDetailsRsuSuspenseQueryHookResult = ReturnType<typeof useOffersDetailsRsuSuspenseQuery>;\nexport type OffersDetailsRsuQueryResult = Apollo.QueryResult<OffersDetailsRsuQuery, OffersDetailsRsuQueryVariables>;\nexport function refetchOffersDetailsRsuQuery(variables: OffersDetailsRsuQueryVariables) {\n      return { query: OffersDetailsRsuDocument, variables: variables };\n    }\nexport const ConfirmOfferInvestorDetailsRsuDocument: TypedDocumentNode<ConfirmOfferInvestorDetailsRsuMutation, ConfirmOfferInvestorDetailsRsuMutationVariables> = gql`\n  mutation confirmOfferInvestorDetailsRsu($offerId: RsuOfferCakeType!, $recipientData: ShareholderDataInput!, $trustData: ShareholderDataInput) {\n  confirmOfferInvestorDetailsRsu(\n    offer: $offerId\n    investorData: $recipientData\n    investorTrustData: $trustData\n  )\n}\n    `;\nexport type ConfirmOfferInvestorDetailsRsuMutationFn = Apollo.MutationFunction<ConfirmOfferInvestorDetailsRsuMutation, ConfirmOfferInvestorDetailsRsuMutationVariables>;\n\n/**\n * __useConfirmOfferInvestorDetailsRsuMutation__\n *\n * To run a mutation, you first call `useConfirmOfferInvestorDetailsRsuMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useConfirmOfferInvestorDetailsRsuMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [confirmOfferInvestorDetailsRsuMutation, { data, loading, error }] = useConfirmOfferInvestorDetailsRsuMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      recipientData: // value for 'recipientData'\n *      trustData: // value for 'trustData'\n *   },\n * });\n */\nexport function useConfirmOfferInvestorDetailsRsuMutation(baseOptions?: Apollo.MutationHookOptions<ConfirmOfferInvestorDetailsRsuMutation, ConfirmOfferInvestorDetailsRsuMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ConfirmOfferInvestorDetailsRsuMutation, ConfirmOfferInvestorDetailsRsuMutationVariables>(ConfirmOfferInvestorDetailsRsuDocument, options);\n      }\nexport type ConfirmOfferInvestorDetailsRsuMutationHookResult = ReturnType<typeof useConfirmOfferInvestorDetailsRsuMutation>;\nexport type ConfirmOfferInvestorDetailsRsuMutationResult = Apollo.MutationResult<ConfirmOfferInvestorDetailsRsuMutation>;\nexport type ConfirmOfferInvestorDetailsRsuMutationOptions = Apollo.BaseMutationOptions<ConfirmOfferInvestorDetailsRsuMutation, ConfirmOfferInvestorDetailsRsuMutationVariables>;\nexport const DeclineOfferRsuDocument: TypedDocumentNode<DeclineOfferRsuMutation, DeclineOfferRsuMutationVariables> = gql`\n  mutation declineOfferRsu($rsuOfferId: RsuOfferCakeType!) {\n  declineOfferRsu(offer: $rsuOfferId)\n}\n    `;\nexport type DeclineOfferRsuMutationFn = Apollo.MutationFunction<DeclineOfferRsuMutation, DeclineOfferRsuMutationVariables>;\n\n/**\n * __useDeclineOfferRsuMutation__\n *\n * To run a mutation, you first call `useDeclineOfferRsuMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeclineOfferRsuMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [declineOfferRsuMutation, { data, loading, error }] = useDeclineOfferRsuMutation({\n *   variables: {\n *      rsuOfferId: // value for 'rsuOfferId'\n *   },\n * });\n */\nexport function useDeclineOfferRsuMutation(baseOptions?: Apollo.MutationHookOptions<DeclineOfferRsuMutation, DeclineOfferRsuMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeclineOfferRsuMutation, DeclineOfferRsuMutationVariables>(DeclineOfferRsuDocument, options);\n      }\nexport type DeclineOfferRsuMutationHookResult = ReturnType<typeof useDeclineOfferRsuMutation>;\nexport type DeclineOfferRsuMutationResult = Apollo.MutationResult<DeclineOfferRsuMutation>;\nexport type DeclineOfferRsuMutationOptions = Apollo.BaseMutationOptions<DeclineOfferRsuMutation, DeclineOfferRsuMutationVariables>;\nexport const SignOfferLetterRsuDocument: TypedDocumentNode<SignOfferLetterRsuMutation, SignOfferLetterRsuMutationVariables> = gql`\n  mutation signOfferLetterRsu($offerId: RsuOfferCakeType!, $witness: WitnessInputType) {\n  signOfferLetterRsu(offer: $offerId, witness: $witness) {\n    urlList\n    signatureRequestId\n    expectedCallbackUrl\n  }\n}\n    `;\nexport type SignOfferLetterRsuMutationFn = Apollo.MutationFunction<SignOfferLetterRsuMutation, SignOfferLetterRsuMutationVariables>;\n\n/**\n * __useSignOfferLetterRsuMutation__\n *\n * To run a mutation, you first call `useSignOfferLetterRsuMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSignOfferLetterRsuMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [signOfferLetterRsuMutation, { data, loading, error }] = useSignOfferLetterRsuMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      witness: // value for 'witness'\n *   },\n * });\n */\nexport function useSignOfferLetterRsuMutation(baseOptions?: Apollo.MutationHookOptions<SignOfferLetterRsuMutation, SignOfferLetterRsuMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SignOfferLetterRsuMutation, SignOfferLetterRsuMutationVariables>(SignOfferLetterRsuDocument, options);\n      }\nexport type SignOfferLetterRsuMutationHookResult = ReturnType<typeof useSignOfferLetterRsuMutation>;\nexport type SignOfferLetterRsuMutationResult = Apollo.MutationResult<SignOfferLetterRsuMutation>;\nexport type SignOfferLetterRsuMutationOptions = Apollo.BaseMutationOptions<SignOfferLetterRsuMutation, SignOfferLetterRsuMutationVariables>;\nexport const OffersDetailsTransfersDocument: TypedDocumentNode<OffersDetailsTransfersQuery, OffersDetailsTransfersQueryVariables> = gql`\n  query OffersDetailsTransfers($offerId: ShareTransferOfferCakeType!) {\n  shareTransferOffer(transferOffer: $offerId) {\n    isSeller\n    id\n    shares\n    amount\n    status\n    fromShareholderConfirmed\n    toShareholderConfirmed\n    fromShareholder {\n      id\n      displayName\n      avatar\n      trustAbn\n      heldInTrust\n      trustName\n      computedType\n      investorData {\n        name\n        email\n        phone\n        jointIndex\n        address {\n          line2\n          line1\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n        companyData {\n          contactPerson\n          identifierType\n          identifierNumber\n          signers {\n            name\n            email\n            role\n          }\n        }\n      }\n      recipient {\n        id\n        displayName\n        avatar\n        trustAbn\n        heldInTrust\n        trustName\n        computedType\n        investorData {\n          name\n          email\n          phone\n          jointIndex\n          address {\n            line2\n            line1\n            locality\n            administrativeArea1\n            postcode\n            country\n          }\n          companyData {\n            contactPerson\n            identifierType\n            identifierNumber\n            signers {\n              name\n              email\n              role\n            }\n          }\n        }\n      }\n    }\n    toShareholder {\n      id\n      displayName\n      avatar\n      trustAbn\n      heldInTrust\n      trustName\n      computedType\n      investorData {\n        name\n        email\n        phone\n        jointIndex\n        address {\n          line2\n          line1\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n        companyData {\n          contactPerson\n          identifierType\n          identifierNumber\n          signers {\n            name\n            email\n            role\n          }\n        }\n      }\n      recipient {\n        id\n        displayName\n        avatar\n        trustAbn\n        heldInTrust\n        trustName\n        computedType\n        investorData {\n          name\n          email\n          phone\n          jointIndex\n          address {\n            line2\n            line1\n            locality\n            administrativeArea1\n            postcode\n            country\n          }\n          companyData {\n            contactPerson\n            identifierType\n            identifierNumber\n            signers {\n              name\n              email\n              role\n            }\n          }\n        }\n      }\n    }\n    sharetype {\n      id\n      name\n      symbol\n    }\n    shareTransferAgreementContract {\n      id\n      created\n      name\n      contractType\n      signatures {\n        name\n        email\n        status\n        extra\n      }\n    }\n    offlineContract {\n      id\n      name\n      contractType\n    }\n    shareTransferRound {\n      id\n      name\n      organisation {\n        id\n        name\n        logo\n        country\n        currency\n        type\n      }\n      documents {\n        id\n        name\n        extension\n        created\n        type\n        status\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useOffersDetailsTransfersQuery__\n *\n * To run a query within a React component, call `useOffersDetailsTransfersQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffersDetailsTransfersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffersDetailsTransfersQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useOffersDetailsTransfersQuery(baseOptions: Apollo.QueryHookOptions<OffersDetailsTransfersQuery, OffersDetailsTransfersQueryVariables> & ({ variables: OffersDetailsTransfersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffersDetailsTransfersQuery, OffersDetailsTransfersQueryVariables>(OffersDetailsTransfersDocument, options);\n      }\nexport function useOffersDetailsTransfersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffersDetailsTransfersQuery, OffersDetailsTransfersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffersDetailsTransfersQuery, OffersDetailsTransfersQueryVariables>(OffersDetailsTransfersDocument, options);\n        }\nexport function useOffersDetailsTransfersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffersDetailsTransfersQuery, OffersDetailsTransfersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffersDetailsTransfersQuery, OffersDetailsTransfersQueryVariables>(OffersDetailsTransfersDocument, options);\n        }\nexport type OffersDetailsTransfersQueryHookResult = ReturnType<typeof useOffersDetailsTransfersQuery>;\nexport type OffersDetailsTransfersLazyQueryHookResult = ReturnType<typeof useOffersDetailsTransfersLazyQuery>;\nexport type OffersDetailsTransfersSuspenseQueryHookResult = ReturnType<typeof useOffersDetailsTransfersSuspenseQuery>;\nexport type OffersDetailsTransfersQueryResult = Apollo.QueryResult<OffersDetailsTransfersQuery, OffersDetailsTransfersQueryVariables>;\nexport function refetchOffersDetailsTransfersQuery(variables: OffersDetailsTransfersQueryVariables) {\n      return { query: OffersDetailsTransfersDocument, variables: variables };\n    }\nexport const ConfirmShareTransferOfferInvestorDetailsDocument: TypedDocumentNode<ConfirmShareTransferOfferInvestorDetailsMutation, ConfirmShareTransferOfferInvestorDetailsMutationVariables> = gql`\n  mutation confirmShareTransferOfferInvestorDetails($offerId: ShareTransferOfferCakeType!, $shareholderData: ShareholderDataInput!) {\n  confirmShareTransferOfferInvestorDetails(\n    transferOffer: $offerId\n    investorData: $shareholderData\n  ) {\n    transferOffer {\n      fromShareholderConfirmed\n      toShareholderConfirmed\n    }\n  }\n}\n    `;\nexport type ConfirmShareTransferOfferInvestorDetailsMutationFn = Apollo.MutationFunction<ConfirmShareTransferOfferInvestorDetailsMutation, ConfirmShareTransferOfferInvestorDetailsMutationVariables>;\n\n/**\n * __useConfirmShareTransferOfferInvestorDetailsMutation__\n *\n * To run a mutation, you first call `useConfirmShareTransferOfferInvestorDetailsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useConfirmShareTransferOfferInvestorDetailsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [confirmShareTransferOfferInvestorDetailsMutation, { data, loading, error }] = useConfirmShareTransferOfferInvestorDetailsMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      shareholderData: // value for 'shareholderData'\n *   },\n * });\n */\nexport function useConfirmShareTransferOfferInvestorDetailsMutation(baseOptions?: Apollo.MutationHookOptions<ConfirmShareTransferOfferInvestorDetailsMutation, ConfirmShareTransferOfferInvestorDetailsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ConfirmShareTransferOfferInvestorDetailsMutation, ConfirmShareTransferOfferInvestorDetailsMutationVariables>(ConfirmShareTransferOfferInvestorDetailsDocument, options);\n      }\nexport type ConfirmShareTransferOfferInvestorDetailsMutationHookResult = ReturnType<typeof useConfirmShareTransferOfferInvestorDetailsMutation>;\nexport type ConfirmShareTransferOfferInvestorDetailsMutationResult = Apollo.MutationResult<ConfirmShareTransferOfferInvestorDetailsMutation>;\nexport type ConfirmShareTransferOfferInvestorDetailsMutationOptions = Apollo.BaseMutationOptions<ConfirmShareTransferOfferInvestorDetailsMutation, ConfirmShareTransferOfferInvestorDetailsMutationVariables>;\nexport const DeclineShareTransferOfferDocument: TypedDocumentNode<DeclineShareTransferOfferMutation, DeclineShareTransferOfferMutationVariables> = gql`\n  mutation declineShareTransferOffer($transferOfferId: ShareTransferOfferCakeType!) {\n  declineShareTransferOffer(transferOffer: $transferOfferId) {\n    ok\n  }\n}\n    `;\nexport type DeclineShareTransferOfferMutationFn = Apollo.MutationFunction<DeclineShareTransferOfferMutation, DeclineShareTransferOfferMutationVariables>;\n\n/**\n * __useDeclineShareTransferOfferMutation__\n *\n * To run a mutation, you first call `useDeclineShareTransferOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeclineShareTransferOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [declineShareTransferOfferMutation, { data, loading, error }] = useDeclineShareTransferOfferMutation({\n *   variables: {\n *      transferOfferId: // value for 'transferOfferId'\n *   },\n * });\n */\nexport function useDeclineShareTransferOfferMutation(baseOptions?: Apollo.MutationHookOptions<DeclineShareTransferOfferMutation, DeclineShareTransferOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeclineShareTransferOfferMutation, DeclineShareTransferOfferMutationVariables>(DeclineShareTransferOfferDocument, options);\n      }\nexport type DeclineShareTransferOfferMutationHookResult = ReturnType<typeof useDeclineShareTransferOfferMutation>;\nexport type DeclineShareTransferOfferMutationResult = Apollo.MutationResult<DeclineShareTransferOfferMutation>;\nexport type DeclineShareTransferOfferMutationOptions = Apollo.BaseMutationOptions<DeclineShareTransferOfferMutation, DeclineShareTransferOfferMutationVariables>;\nexport const SignShareTransferAgreementDocument: TypedDocumentNode<SignShareTransferAgreementMutation, SignShareTransferAgreementMutationVariables> = gql`\n  mutation signShareTransferAgreement($transferOffer: ShareTransferOfferCakeType!) {\n  signShareTransferAgreement(transferOffer: $transferOffer) {\n    urlList\n    signatureRequestId\n    expectedCallbackUrl\n  }\n}\n    `;\nexport type SignShareTransferAgreementMutationFn = Apollo.MutationFunction<SignShareTransferAgreementMutation, SignShareTransferAgreementMutationVariables>;\n\n/**\n * __useSignShareTransferAgreementMutation__\n *\n * To run a mutation, you first call `useSignShareTransferAgreementMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSignShareTransferAgreementMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [signShareTransferAgreementMutation, { data, loading, error }] = useSignShareTransferAgreementMutation({\n *   variables: {\n *      transferOffer: // value for 'transferOffer'\n *   },\n * });\n */\nexport function useSignShareTransferAgreementMutation(baseOptions?: Apollo.MutationHookOptions<SignShareTransferAgreementMutation, SignShareTransferAgreementMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SignShareTransferAgreementMutation, SignShareTransferAgreementMutationVariables>(SignShareTransferAgreementDocument, options);\n      }\nexport type SignShareTransferAgreementMutationHookResult = ReturnType<typeof useSignShareTransferAgreementMutation>;\nexport type SignShareTransferAgreementMutationResult = Apollo.MutationResult<SignShareTransferAgreementMutation>;\nexport type SignShareTransferAgreementMutationOptions = Apollo.BaseMutationOptions<SignShareTransferAgreementMutation, SignShareTransferAgreementMutationVariables>;\nexport const PortfolioOfferDetailsEsopDocument: TypedDocumentNode<PortfolioOfferDetailsEsopQuery, PortfolioOfferDetailsEsopQueryVariables> = gql`\n  query PortfolioOfferDetailsEsop($offerId: UUID!) {\n  esopOfferDetails(offerId: $offerId) {\n    id\n    shareholder {\n      displayName\n      avatar\n    }\n    group {\n      plan {\n        name\n        organisation {\n          id\n          name\n          logo: logoImageLink\n          currency\n          valuationVisibleToOptionholders\n          ownershipVisibleToOptionholders\n          fullyDilutedShares\n          totalShares\n          totalSharesUnexercised\n          valuationAt {\n            valuation\n          }\n        }\n      }\n      country\n      exercisePrice\n      optionPrice\n      currency\n    }\n    optionPrice\n    exercisePrice\n    currency\n    granted\n    vested\n    exercised\n    lapsed\n    availableToExercise\n    transactionSet: esoptransactionSet {\n      type\n      transactionDate\n      vestingValue\n    }\n    esopvestingeventSet {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: esoptransactionSet {\n        id\n        transactionDate\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n        reminderDate\n      }\n    }\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    offerLetterTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    planRulesTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    offerLetter {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    planRules {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioOfferDetailsEsopQuery__\n *\n * To run a query within a React component, call `usePortfolioOfferDetailsEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioOfferDetailsEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioOfferDetailsEsopQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function usePortfolioOfferDetailsEsopQuery(baseOptions: Apollo.QueryHookOptions<PortfolioOfferDetailsEsopQuery, PortfolioOfferDetailsEsopQueryVariables> & ({ variables: PortfolioOfferDetailsEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioOfferDetailsEsopQuery, PortfolioOfferDetailsEsopQueryVariables>(PortfolioOfferDetailsEsopDocument, options);\n      }\nexport function usePortfolioOfferDetailsEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioOfferDetailsEsopQuery, PortfolioOfferDetailsEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioOfferDetailsEsopQuery, PortfolioOfferDetailsEsopQueryVariables>(PortfolioOfferDetailsEsopDocument, options);\n        }\nexport function usePortfolioOfferDetailsEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioOfferDetailsEsopQuery, PortfolioOfferDetailsEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioOfferDetailsEsopQuery, PortfolioOfferDetailsEsopQueryVariables>(PortfolioOfferDetailsEsopDocument, options);\n        }\nexport type PortfolioOfferDetailsEsopQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsEsopQuery>;\nexport type PortfolioOfferDetailsEsopLazyQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsEsopLazyQuery>;\nexport type PortfolioOfferDetailsEsopSuspenseQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsEsopSuspenseQuery>;\nexport type PortfolioOfferDetailsEsopQueryResult = Apollo.QueryResult<PortfolioOfferDetailsEsopQuery, PortfolioOfferDetailsEsopQueryVariables>;\nexport function refetchPortfolioOfferDetailsEsopQuery(variables: PortfolioOfferDetailsEsopQueryVariables) {\n      return { query: PortfolioOfferDetailsEsopDocument, variables: variables };\n    }\nexport const PortfolioOffersListEsopDocument: TypedDocumentNode<PortfolioOffersListEsopQuery, PortfolioOffersListEsopQueryVariables> = gql`\n  query PortfolioOffersListEsop($employee: ShareholderCakeType!) {\n  esopOfferList(employee: $employee) {\n    id\n    group {\n      id\n      country\n      plan {\n        name\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioOffersListEsopQuery__\n *\n * To run a query within a React component, call `usePortfolioOffersListEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioOffersListEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioOffersListEsopQuery({\n *   variables: {\n *      employee: // value for 'employee'\n *   },\n * });\n */\nexport function usePortfolioOffersListEsopQuery(baseOptions: Apollo.QueryHookOptions<PortfolioOffersListEsopQuery, PortfolioOffersListEsopQueryVariables> & ({ variables: PortfolioOffersListEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioOffersListEsopQuery, PortfolioOffersListEsopQueryVariables>(PortfolioOffersListEsopDocument, options);\n      }\nexport function usePortfolioOffersListEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioOffersListEsopQuery, PortfolioOffersListEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioOffersListEsopQuery, PortfolioOffersListEsopQueryVariables>(PortfolioOffersListEsopDocument, options);\n        }\nexport function usePortfolioOffersListEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioOffersListEsopQuery, PortfolioOffersListEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioOffersListEsopQuery, PortfolioOffersListEsopQueryVariables>(PortfolioOffersListEsopDocument, options);\n        }\nexport type PortfolioOffersListEsopQueryHookResult = ReturnType<typeof usePortfolioOffersListEsopQuery>;\nexport type PortfolioOffersListEsopLazyQueryHookResult = ReturnType<typeof usePortfolioOffersListEsopLazyQuery>;\nexport type PortfolioOffersListEsopSuspenseQueryHookResult = ReturnType<typeof usePortfolioOffersListEsopSuspenseQuery>;\nexport type PortfolioOffersListEsopQueryResult = Apollo.QueryResult<PortfolioOffersListEsopQuery, PortfolioOffersListEsopQueryVariables>;\nexport function refetchPortfolioOffersListEsopQuery(variables: PortfolioOffersListEsopQueryVariables) {\n      return { query: PortfolioOffersListEsopDocument, variables: variables };\n    }\nexport const RequestExerciseDocument: TypedDocumentNode<RequestExerciseMutation, RequestExerciseMutationVariables> = gql`\n  mutation requestExercise($offerId: EsopOfferCakeType!, $options: PositiveInteger!, $taxWithholding: CakeDecimal) {\n  requestExercise(\n    offer: $offerId\n    options: $options\n    taxWithholding: $taxWithholding\n  )\n}\n    `;\nexport type RequestExerciseMutationFn = Apollo.MutationFunction<RequestExerciseMutation, RequestExerciseMutationVariables>;\n\n/**\n * __useRequestExerciseMutation__\n *\n * To run a mutation, you first call `useRequestExerciseMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRequestExerciseMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [requestExerciseMutation, { data, loading, error }] = useRequestExerciseMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      options: // value for 'options'\n *      taxWithholding: // value for 'taxWithholding'\n *   },\n * });\n */\nexport function useRequestExerciseMutation(baseOptions?: Apollo.MutationHookOptions<RequestExerciseMutation, RequestExerciseMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RequestExerciseMutation, RequestExerciseMutationVariables>(RequestExerciseDocument, options);\n      }\nexport type RequestExerciseMutationHookResult = ReturnType<typeof useRequestExerciseMutation>;\nexport type RequestExerciseMutationResult = Apollo.MutationResult<RequestExerciseMutation>;\nexport type RequestExerciseMutationOptions = Apollo.BaseMutationOptions<RequestExerciseMutation, RequestExerciseMutationVariables>;\nexport const CanRequestExerciseDocument: TypedDocumentNode<CanRequestExerciseQuery, CanRequestExerciseQueryVariables> = gql`\n  query canRequestExercise($organisationId: OrganisationCakeType!) {\n  canRequestExercise(organisation: $organisationId)\n}\n    `;\n\n/**\n * __useCanRequestExerciseQuery__\n *\n * To run a query within a React component, call `useCanRequestExerciseQuery` and pass it any options that fit your needs.\n * When your component renders, `useCanRequestExerciseQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCanRequestExerciseQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useCanRequestExerciseQuery(baseOptions: Apollo.QueryHookOptions<CanRequestExerciseQuery, CanRequestExerciseQueryVariables> & ({ variables: CanRequestExerciseQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<CanRequestExerciseQuery, CanRequestExerciseQueryVariables>(CanRequestExerciseDocument, options);\n      }\nexport function useCanRequestExerciseLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CanRequestExerciseQuery, CanRequestExerciseQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<CanRequestExerciseQuery, CanRequestExerciseQueryVariables>(CanRequestExerciseDocument, options);\n        }\nexport function useCanRequestExerciseSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<CanRequestExerciseQuery, CanRequestExerciseQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<CanRequestExerciseQuery, CanRequestExerciseQueryVariables>(CanRequestExerciseDocument, options);\n        }\nexport type CanRequestExerciseQueryHookResult = ReturnType<typeof useCanRequestExerciseQuery>;\nexport type CanRequestExerciseLazyQueryHookResult = ReturnType<typeof useCanRequestExerciseLazyQuery>;\nexport type CanRequestExerciseSuspenseQueryHookResult = ReturnType<typeof useCanRequestExerciseSuspenseQuery>;\nexport type CanRequestExerciseQueryResult = Apollo.QueryResult<CanRequestExerciseQuery, CanRequestExerciseQueryVariables>;\nexport function refetchCanRequestExerciseQuery(variables: CanRequestExerciseQueryVariables) {\n      return { query: CanRequestExerciseDocument, variables: variables };\n    }\nexport const PrepareRequestExerciseDocument: TypedDocumentNode<PrepareRequestExerciseQuery, PrepareRequestExerciseQueryVariables> = gql`\n  query prepareRequestExercise($offerId: UUID!) {\n  esopOfferDetails(offerId: $offerId) {\n    group {\n      country\n      plan {\n        organisation {\n          id\n          name\n          logo: logoImageLink\n          type\n        }\n      }\n    }\n    exercisePrice\n    currency\n    availableToExercise\n    requestedToExercise\n    granted\n    lapsed\n    exercised\n  }\n}\n    `;\n\n/**\n * __usePrepareRequestExerciseQuery__\n *\n * To run a query within a React component, call `usePrepareRequestExerciseQuery` and pass it any options that fit your needs.\n * When your component renders, `usePrepareRequestExerciseQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePrepareRequestExerciseQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function usePrepareRequestExerciseQuery(baseOptions: Apollo.QueryHookOptions<PrepareRequestExerciseQuery, PrepareRequestExerciseQueryVariables> & ({ variables: PrepareRequestExerciseQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PrepareRequestExerciseQuery, PrepareRequestExerciseQueryVariables>(PrepareRequestExerciseDocument, options);\n      }\nexport function usePrepareRequestExerciseLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PrepareRequestExerciseQuery, PrepareRequestExerciseQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PrepareRequestExerciseQuery, PrepareRequestExerciseQueryVariables>(PrepareRequestExerciseDocument, options);\n        }\nexport function usePrepareRequestExerciseSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PrepareRequestExerciseQuery, PrepareRequestExerciseQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PrepareRequestExerciseQuery, PrepareRequestExerciseQueryVariables>(PrepareRequestExerciseDocument, options);\n        }\nexport type PrepareRequestExerciseQueryHookResult = ReturnType<typeof usePrepareRequestExerciseQuery>;\nexport type PrepareRequestExerciseLazyQueryHookResult = ReturnType<typeof usePrepareRequestExerciseLazyQuery>;\nexport type PrepareRequestExerciseSuspenseQueryHookResult = ReturnType<typeof usePrepareRequestExerciseSuspenseQuery>;\nexport type PrepareRequestExerciseQueryResult = Apollo.QueryResult<PrepareRequestExerciseQuery, PrepareRequestExerciseQueryVariables>;\nexport function refetchPrepareRequestExerciseQuery(variables: PrepareRequestExerciseQueryVariables) {\n      return { query: PrepareRequestExerciseDocument, variables: variables };\n    }\nexport const GetExerciseRequestDocument: TypedDocumentNode<GetExerciseRequestQuery, GetExerciseRequestQueryVariables> = gql`\n  query getExerciseRequest($exerciseRequest: OptionExerciseRequestCakeType!) {\n  exerciseRequest(exerciseRequest: $exerciseRequest) {\n    id\n    vestingValue\n    status\n    taxWithholding\n    recipientReference\n    offer {\n      id\n      currency\n      exercisePrice\n      group {\n        plan {\n          organisation {\n            optionexerciserequestsettings {\n              id\n              paymentDetails {\n                accountName\n                accountNumber\n                routingNumber\n                additionalInstructions\n              }\n              exerciseNoticeTemplate {\n                id\n              }\n            }\n            id\n            name\n            logo: logoImageLink\n            type\n            country\n          }\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetExerciseRequestQuery__\n *\n * To run a query within a React component, call `useGetExerciseRequestQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetExerciseRequestQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetExerciseRequestQuery({\n *   variables: {\n *      exerciseRequest: // value for 'exerciseRequest'\n *   },\n * });\n */\nexport function useGetExerciseRequestQuery(baseOptions: Apollo.QueryHookOptions<GetExerciseRequestQuery, GetExerciseRequestQueryVariables> & ({ variables: GetExerciseRequestQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetExerciseRequestQuery, GetExerciseRequestQueryVariables>(GetExerciseRequestDocument, options);\n      }\nexport function useGetExerciseRequestLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetExerciseRequestQuery, GetExerciseRequestQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetExerciseRequestQuery, GetExerciseRequestQueryVariables>(GetExerciseRequestDocument, options);\n        }\nexport function useGetExerciseRequestSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetExerciseRequestQuery, GetExerciseRequestQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetExerciseRequestQuery, GetExerciseRequestQueryVariables>(GetExerciseRequestDocument, options);\n        }\nexport type GetExerciseRequestQueryHookResult = ReturnType<typeof useGetExerciseRequestQuery>;\nexport type GetExerciseRequestLazyQueryHookResult = ReturnType<typeof useGetExerciseRequestLazyQuery>;\nexport type GetExerciseRequestSuspenseQueryHookResult = ReturnType<typeof useGetExerciseRequestSuspenseQuery>;\nexport type GetExerciseRequestQueryResult = Apollo.QueryResult<GetExerciseRequestQuery, GetExerciseRequestQueryVariables>;\nexport function refetchGetExerciseRequestQuery(variables: GetExerciseRequestQueryVariables) {\n      return { query: GetExerciseRequestDocument, variables: variables };\n    }\nexport const ExerciseRequestsFromOfferDocument: TypedDocumentNode<ExerciseRequestsFromOfferQuery, ExerciseRequestsFromOfferQueryVariables> = gql`\n  query exerciseRequestsFromOffer($offerId: EsopOfferCakeType!, $page: Int, $itemsPerPage: Int) {\n  exerciseRequestsFromOffer(\n    offer: $offerId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    pageData {\n      id\n      created\n      status\n      vestingValue\n      taxWithholding\n      recipientReference\n      shareCertificateId\n      offer {\n        currency\n        id\n        shareholder {\n          id\n          displayName\n          avatar\n        }\n        exercisePrice\n      }\n      exerciseNotice {\n        id\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useExerciseRequestsFromOfferQuery__\n *\n * To run a query within a React component, call `useExerciseRequestsFromOfferQuery` and pass it any options that fit your needs.\n * When your component renders, `useExerciseRequestsFromOfferQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useExerciseRequestsFromOfferQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useExerciseRequestsFromOfferQuery(baseOptions: Apollo.QueryHookOptions<ExerciseRequestsFromOfferQuery, ExerciseRequestsFromOfferQueryVariables> & ({ variables: ExerciseRequestsFromOfferQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ExerciseRequestsFromOfferQuery, ExerciseRequestsFromOfferQueryVariables>(ExerciseRequestsFromOfferDocument, options);\n      }\nexport function useExerciseRequestsFromOfferLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ExerciseRequestsFromOfferQuery, ExerciseRequestsFromOfferQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ExerciseRequestsFromOfferQuery, ExerciseRequestsFromOfferQueryVariables>(ExerciseRequestsFromOfferDocument, options);\n        }\nexport function useExerciseRequestsFromOfferSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ExerciseRequestsFromOfferQuery, ExerciseRequestsFromOfferQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ExerciseRequestsFromOfferQuery, ExerciseRequestsFromOfferQueryVariables>(ExerciseRequestsFromOfferDocument, options);\n        }\nexport type ExerciseRequestsFromOfferQueryHookResult = ReturnType<typeof useExerciseRequestsFromOfferQuery>;\nexport type ExerciseRequestsFromOfferLazyQueryHookResult = ReturnType<typeof useExerciseRequestsFromOfferLazyQuery>;\nexport type ExerciseRequestsFromOfferSuspenseQueryHookResult = ReturnType<typeof useExerciseRequestsFromOfferSuspenseQuery>;\nexport type ExerciseRequestsFromOfferQueryResult = Apollo.QueryResult<ExerciseRequestsFromOfferQuery, ExerciseRequestsFromOfferQueryVariables>;\nexport function refetchExerciseRequestsFromOfferQuery(variables: ExerciseRequestsFromOfferQueryVariables) {\n      return { query: ExerciseRequestsFromOfferDocument, variables: variables };\n    }\nexport const SubmitExercisePaymentDocument: TypedDocumentNode<SubmitExercisePaymentMutation, SubmitExercisePaymentMutationVariables> = gql`\n  mutation submitExercisePayment($exerciseRequestId: OptionExerciseRequestCakeType!, $signature: String, $variant: String) {\n  submitExercisePayment(\n    exerciseRequest: $exerciseRequestId\n    signature: $signature\n    variant: $variant\n  )\n}\n    `;\nexport type SubmitExercisePaymentMutationFn = Apollo.MutationFunction<SubmitExercisePaymentMutation, SubmitExercisePaymentMutationVariables>;\n\n/**\n * __useSubmitExercisePaymentMutation__\n *\n * To run a mutation, you first call `useSubmitExercisePaymentMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSubmitExercisePaymentMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [submitExercisePaymentMutation, { data, loading, error }] = useSubmitExercisePaymentMutation({\n *   variables: {\n *      exerciseRequestId: // value for 'exerciseRequestId'\n *      signature: // value for 'signature'\n *      variant: // value for 'variant'\n *   },\n * });\n */\nexport function useSubmitExercisePaymentMutation(baseOptions?: Apollo.MutationHookOptions<SubmitExercisePaymentMutation, SubmitExercisePaymentMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SubmitExercisePaymentMutation, SubmitExercisePaymentMutationVariables>(SubmitExercisePaymentDocument, options);\n      }\nexport type SubmitExercisePaymentMutationHookResult = ReturnType<typeof useSubmitExercisePaymentMutation>;\nexport type SubmitExercisePaymentMutationResult = Apollo.MutationResult<SubmitExercisePaymentMutation>;\nexport type SubmitExercisePaymentMutationOptions = Apollo.BaseMutationOptions<SubmitExercisePaymentMutation, SubmitExercisePaymentMutationVariables>;\nexport const PortfolioOffersListEssFounderVestingDocument: TypedDocumentNode<PortfolioOffersListEssFounderVestingQuery, PortfolioOffersListEssFounderVestingQueryVariables> = gql`\n  query PortfolioOffersListEssFounderVesting($employee: ShareholderCakeType!) {\n  essOfferList(employee: $employee) {\n    id\n    group {\n      id\n      country\n      plan {\n        name\n      }\n    }\n  }\n  founderVestingOfferList(employee: $employee) {\n    id\n    group {\n      id\n      country\n      plan {\n        name\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioOffersListEssFounderVestingQuery__\n *\n * To run a query within a React component, call `usePortfolioOffersListEssFounderVestingQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioOffersListEssFounderVestingQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioOffersListEssFounderVestingQuery({\n *   variables: {\n *      employee: // value for 'employee'\n *   },\n * });\n */\nexport function usePortfolioOffersListEssFounderVestingQuery(baseOptions: Apollo.QueryHookOptions<PortfolioOffersListEssFounderVestingQuery, PortfolioOffersListEssFounderVestingQueryVariables> & ({ variables: PortfolioOffersListEssFounderVestingQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioOffersListEssFounderVestingQuery, PortfolioOffersListEssFounderVestingQueryVariables>(PortfolioOffersListEssFounderVestingDocument, options);\n      }\nexport function usePortfolioOffersListEssFounderVestingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioOffersListEssFounderVestingQuery, PortfolioOffersListEssFounderVestingQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioOffersListEssFounderVestingQuery, PortfolioOffersListEssFounderVestingQueryVariables>(PortfolioOffersListEssFounderVestingDocument, options);\n        }\nexport function usePortfolioOffersListEssFounderVestingSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioOffersListEssFounderVestingQuery, PortfolioOffersListEssFounderVestingQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioOffersListEssFounderVestingQuery, PortfolioOffersListEssFounderVestingQueryVariables>(PortfolioOffersListEssFounderVestingDocument, options);\n        }\nexport type PortfolioOffersListEssFounderVestingQueryHookResult = ReturnType<typeof usePortfolioOffersListEssFounderVestingQuery>;\nexport type PortfolioOffersListEssFounderVestingLazyQueryHookResult = ReturnType<typeof usePortfolioOffersListEssFounderVestingLazyQuery>;\nexport type PortfolioOffersListEssFounderVestingSuspenseQueryHookResult = ReturnType<typeof usePortfolioOffersListEssFounderVestingSuspenseQuery>;\nexport type PortfolioOffersListEssFounderVestingQueryResult = Apollo.QueryResult<PortfolioOffersListEssFounderVestingQuery, PortfolioOffersListEssFounderVestingQueryVariables>;\nexport function refetchPortfolioOffersListEssFounderVestingQuery(variables: PortfolioOffersListEssFounderVestingQueryVariables) {\n      return { query: PortfolioOffersListEssFounderVestingDocument, variables: variables };\n    }\nexport const PortfolioOfferDetailsEssFounderVestingDocument: TypedDocumentNode<PortfolioOfferDetailsEssFounderVestingQuery, PortfolioOfferDetailsEssFounderVestingQueryVariables> = gql`\n  query PortfolioOfferDetailsEssFounderVesting($offerId: UUID!) {\n  essOfferDetails(offerId: $offerId) {\n    id\n    shareholder {\n      displayName\n      avatar\n    }\n    group {\n      plan {\n        name\n        organisation {\n          id\n          name\n          logo: logoImageLink\n          currency\n          valuationVisibleToShareholders\n          valuationVisibleToOptionholders\n          ownershipVisibleToShareholders\n          ownershipVisibleToOptionholders\n          fullyDilutedShares\n          totalShares\n          totalSharesUnexercised\n          valuationAt {\n            valuation\n          }\n        }\n      }\n      country\n    }\n    granted\n    dateGranted\n    vested\n    lapsed\n    loanFunded\n    sharePrice\n    transactionSet: esstransactionSet {\n      type\n      transactionDate\n      vestingValue\n    }\n    essvestingeventSet {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: esstransactionSet {\n        id\n        transactionDate\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n        reminderDate\n      }\n    }\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    offerLetterTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    planRulesTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    offerLetter {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    planRules {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n  }\n  founderVestingOfferDetails(offerId: $offerId) {\n    id\n    shareholder {\n      displayName\n      avatar\n    }\n    group {\n      plan {\n        name\n        organisation {\n          id\n          name\n          logo: logoImageLink\n          currency\n          valuationVisibleToShareholders\n          valuationVisibleToOptionholders\n          ownershipVisibleToShareholders\n          ownershipVisibleToOptionholders\n          fullyDilutedShares\n          totalShares\n          totalSharesUnexercised\n          valuationAt {\n            valuation\n          }\n        }\n      }\n      country\n    }\n    granted\n    dateGranted\n    vested\n    lapsed\n    loanFunded\n    sharePrice\n    hasDownloaded83bForm\n    transactionSet: foundervestingtransactionSet {\n      type\n      transactionDate\n      vestingValue\n    }\n    foundervestingvestingeventSet {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: foundervestingtransactionSet {\n        id\n        transactionDate\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n        reminderDate\n      }\n    }\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    offerLetterTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    planRulesTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    offerLetter {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    planRules {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioOfferDetailsEssFounderVestingQuery__\n *\n * To run a query within a React component, call `usePortfolioOfferDetailsEssFounderVestingQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioOfferDetailsEssFounderVestingQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioOfferDetailsEssFounderVestingQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function usePortfolioOfferDetailsEssFounderVestingQuery(baseOptions: Apollo.QueryHookOptions<PortfolioOfferDetailsEssFounderVestingQuery, PortfolioOfferDetailsEssFounderVestingQueryVariables> & ({ variables: PortfolioOfferDetailsEssFounderVestingQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioOfferDetailsEssFounderVestingQuery, PortfolioOfferDetailsEssFounderVestingQueryVariables>(PortfolioOfferDetailsEssFounderVestingDocument, options);\n      }\nexport function usePortfolioOfferDetailsEssFounderVestingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioOfferDetailsEssFounderVestingQuery, PortfolioOfferDetailsEssFounderVestingQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioOfferDetailsEssFounderVestingQuery, PortfolioOfferDetailsEssFounderVestingQueryVariables>(PortfolioOfferDetailsEssFounderVestingDocument, options);\n        }\nexport function usePortfolioOfferDetailsEssFounderVestingSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioOfferDetailsEssFounderVestingQuery, PortfolioOfferDetailsEssFounderVestingQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioOfferDetailsEssFounderVestingQuery, PortfolioOfferDetailsEssFounderVestingQueryVariables>(PortfolioOfferDetailsEssFounderVestingDocument, options);\n        }\nexport type PortfolioOfferDetailsEssFounderVestingQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsEssFounderVestingQuery>;\nexport type PortfolioOfferDetailsEssFounderVestingLazyQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsEssFounderVestingLazyQuery>;\nexport type PortfolioOfferDetailsEssFounderVestingSuspenseQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsEssFounderVestingSuspenseQuery>;\nexport type PortfolioOfferDetailsEssFounderVestingQueryResult = Apollo.QueryResult<PortfolioOfferDetailsEssFounderVestingQuery, PortfolioOfferDetailsEssFounderVestingQueryVariables>;\nexport function refetchPortfolioOfferDetailsEssFounderVestingQuery(variables: PortfolioOfferDetailsEssFounderVestingQueryVariables) {\n      return { query: PortfolioOfferDetailsEssFounderVestingDocument, variables: variables };\n    }\nexport const PortfolioHomeDocument: TypedDocumentNode<PortfolioHomeQuery, PortfolioHomeQueryVariables> = gql`\n  query PortfolioHome {\n  portfolioHome {\n    shareholder {\n      id\n      organisation {\n        id\n        name\n        type\n        country\n        logo: logoImageLink\n        totalShares\n        currency\n        totalSharesUnexercised\n        valuationAt {\n          valuation\n        }\n        valuationVisibleToShareholders\n        valuationVisibleToOptionholders\n        ownershipVisibleToShareholders\n        ownershipVisibleToOptionholders\n      }\n    }\n    groupedShareholdings {\n      totalShares\n      totalInvested\n    }\n    groupedShareholdingsInTrust {\n      totalShares\n      totalInvested\n    }\n    groupedNoteholdings(excludeResolved: true) {\n      totalNotes\n      totalInvested\n    }\n    groupedPlanData {\n      planType\n      totalVested\n      totalExercised\n      totalLapsed\n      totalGranted\n      vestingNext {\n        date\n        vestingValue\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioHomeQuery__\n *\n * To run a query within a React component, call `usePortfolioHomeQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioHomeQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioHomeQuery({\n *   variables: {\n *   },\n * });\n */\nexport function usePortfolioHomeQuery(baseOptions?: Apollo.QueryHookOptions<PortfolioHomeQuery, PortfolioHomeQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioHomeQuery, PortfolioHomeQueryVariables>(PortfolioHomeDocument, options);\n      }\nexport function usePortfolioHomeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioHomeQuery, PortfolioHomeQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioHomeQuery, PortfolioHomeQueryVariables>(PortfolioHomeDocument, options);\n        }\nexport function usePortfolioHomeSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioHomeQuery, PortfolioHomeQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioHomeQuery, PortfolioHomeQueryVariables>(PortfolioHomeDocument, options);\n        }\nexport type PortfolioHomeQueryHookResult = ReturnType<typeof usePortfolioHomeQuery>;\nexport type PortfolioHomeLazyQueryHookResult = ReturnType<typeof usePortfolioHomeLazyQuery>;\nexport type PortfolioHomeSuspenseQueryHookResult = ReturnType<typeof usePortfolioHomeSuspenseQuery>;\nexport type PortfolioHomeQueryResult = Apollo.QueryResult<PortfolioHomeQuery, PortfolioHomeQueryVariables>;\nexport function refetchPortfolioHomeQuery(variables?: PortfolioHomeQueryVariables) {\n      return { query: PortfolioHomeDocument, variables: variables };\n    }\nexport const PortfolioShareDetailsDocument: TypedDocumentNode<PortfolioShareDetailsQuery, PortfolioShareDetailsQueryVariables> = gql`\n  query PortfolioShareDetails($shareholderId: UUID!) {\n  shareholderTransactions(shareholderId: $shareholderId) {\n    id\n    displayName\n    avatar\n    organisation {\n      id\n      name\n      type\n      logo: logoImageLink\n      totalShares\n      totalSharesUnexercised\n      valuationAt {\n        valuation\n      }\n      valuationVisibleToShareholders\n      valuationVisibleToOptionholders\n      ownershipVisibleToShareholders\n      ownershipVisibleToOptionholders\n      currency\n      country\n    }\n    shareholdings {\n      transactionId\n      transactionDate\n      transactionType\n      shares\n      amount\n      paidInTransfer\n      sharetype {\n        symbol\n      }\n      accumulatedShares\n      unpaid\n      lastShareCertificate {\n        id\n        name\n        type\n        extension\n      }\n    }\n    groupedShareholdings {\n      totalShares\n      totalPaidInIssuance\n      totalUnpaid\n      totalTransferPaid\n      totalTransferReceived\n      sharetype {\n        id\n        symbol\n      }\n    }\n    groupedBeneficiariesShareholdings {\n      beneficiary {\n        id\n        displayName\n        hasLoggedIn\n      }\n      totalShares\n      totalPaidInIssuance\n      totalUnpaid\n      totalTransferPaid\n      totalTransferReceived\n      sharetype {\n        name\n        symbol\n      }\n    }\n    lastShareCertificate {\n      id\n      name\n      type\n      extension\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioShareDetailsQuery__\n *\n * To run a query within a React component, call `usePortfolioShareDetailsQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioShareDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioShareDetailsQuery({\n *   variables: {\n *      shareholderId: // value for 'shareholderId'\n *   },\n * });\n */\nexport function usePortfolioShareDetailsQuery(baseOptions: Apollo.QueryHookOptions<PortfolioShareDetailsQuery, PortfolioShareDetailsQueryVariables> & ({ variables: PortfolioShareDetailsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioShareDetailsQuery, PortfolioShareDetailsQueryVariables>(PortfolioShareDetailsDocument, options);\n      }\nexport function usePortfolioShareDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioShareDetailsQuery, PortfolioShareDetailsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioShareDetailsQuery, PortfolioShareDetailsQueryVariables>(PortfolioShareDetailsDocument, options);\n        }\nexport function usePortfolioShareDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioShareDetailsQuery, PortfolioShareDetailsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioShareDetailsQuery, PortfolioShareDetailsQueryVariables>(PortfolioShareDetailsDocument, options);\n        }\nexport type PortfolioShareDetailsQueryHookResult = ReturnType<typeof usePortfolioShareDetailsQuery>;\nexport type PortfolioShareDetailsLazyQueryHookResult = ReturnType<typeof usePortfolioShareDetailsLazyQuery>;\nexport type PortfolioShareDetailsSuspenseQueryHookResult = ReturnType<typeof usePortfolioShareDetailsSuspenseQuery>;\nexport type PortfolioShareDetailsQueryResult = Apollo.QueryResult<PortfolioShareDetailsQuery, PortfolioShareDetailsQueryVariables>;\nexport function refetchPortfolioShareDetailsQuery(variables: PortfolioShareDetailsQueryVariables) {\n      return { query: PortfolioShareDetailsDocument, variables: variables };\n    }\nexport const PortfolioBeneficialHoldingsDetailsDocument: TypedDocumentNode<PortfolioBeneficialHoldingsDetailsQuery, PortfolioBeneficialHoldingsDetailsQueryVariables> = gql`\n  query PortfolioBeneficialHoldingsDetails($shareholderId: UUID!) {\n  shareholderTransactions(shareholderId: $shareholderId) {\n    id\n    displayName\n    organisation {\n      id\n      name\n      type\n      logo: logoImageLink\n      totalShares\n      totalSharesUnexercised\n      valuationAt {\n        valuation\n      }\n      valuationVisibleToShareholders\n      valuationVisibleToOptionholders\n      ownershipVisibleToShareholders\n      ownershipVisibleToOptionholders\n      currency\n      country\n    }\n    beneficiaryShareholdings {\n      shareholderId\n      transactionId\n      transactionDate\n      transactionType\n      shares\n      amount\n      paidInTransfer\n      sharetype {\n        symbol\n      }\n      accumulatedShares\n      unpaid\n    }\n    groupedShareholdingsInTrust {\n      totalShares\n      totalPaidInIssuance\n      totalUnpaid\n      totalTransferPaid\n      totalTransferReceived\n      trustee {\n        id\n        displayName\n        trust {\n          id\n          name\n        }\n      }\n      sharetype {\n        id\n        symbol\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioBeneficialHoldingsDetailsQuery__\n *\n * To run a query within a React component, call `usePortfolioBeneficialHoldingsDetailsQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioBeneficialHoldingsDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioBeneficialHoldingsDetailsQuery({\n *   variables: {\n *      shareholderId: // value for 'shareholderId'\n *   },\n * });\n */\nexport function usePortfolioBeneficialHoldingsDetailsQuery(baseOptions: Apollo.QueryHookOptions<PortfolioBeneficialHoldingsDetailsQuery, PortfolioBeneficialHoldingsDetailsQueryVariables> & ({ variables: PortfolioBeneficialHoldingsDetailsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioBeneficialHoldingsDetailsQuery, PortfolioBeneficialHoldingsDetailsQueryVariables>(PortfolioBeneficialHoldingsDetailsDocument, options);\n      }\nexport function usePortfolioBeneficialHoldingsDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioBeneficialHoldingsDetailsQuery, PortfolioBeneficialHoldingsDetailsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioBeneficialHoldingsDetailsQuery, PortfolioBeneficialHoldingsDetailsQueryVariables>(PortfolioBeneficialHoldingsDetailsDocument, options);\n        }\nexport function usePortfolioBeneficialHoldingsDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioBeneficialHoldingsDetailsQuery, PortfolioBeneficialHoldingsDetailsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioBeneficialHoldingsDetailsQuery, PortfolioBeneficialHoldingsDetailsQueryVariables>(PortfolioBeneficialHoldingsDetailsDocument, options);\n        }\nexport type PortfolioBeneficialHoldingsDetailsQueryHookResult = ReturnType<typeof usePortfolioBeneficialHoldingsDetailsQuery>;\nexport type PortfolioBeneficialHoldingsDetailsLazyQueryHookResult = ReturnType<typeof usePortfolioBeneficialHoldingsDetailsLazyQuery>;\nexport type PortfolioBeneficialHoldingsDetailsSuspenseQueryHookResult = ReturnType<typeof usePortfolioBeneficialHoldingsDetailsSuspenseQuery>;\nexport type PortfolioBeneficialHoldingsDetailsQueryResult = Apollo.QueryResult<PortfolioBeneficialHoldingsDetailsQuery, PortfolioBeneficialHoldingsDetailsQueryVariables>;\nexport function refetchPortfolioBeneficialHoldingsDetailsQuery(variables: PortfolioBeneficialHoldingsDetailsQueryVariables) {\n      return { query: PortfolioBeneficialHoldingsDetailsDocument, variables: variables };\n    }\nexport const PortfolioDetailsDocument: TypedDocumentNode<PortfolioDetailsQuery, PortfolioDetailsQueryVariables> = gql`\n  query PortfolioDetails($shareholderId: ShareholderCakeType) {\n  portfolioHome(shareholder: $shareholderId) {\n    shareholder {\n      id\n      organisation {\n        id\n        type\n        country\n        name\n      }\n    }\n    shareholdings {\n      transactionId\n    }\n    groupedShareholdings {\n      totalShares\n    }\n    groupedShareholdingsInTrust {\n      totalShares\n    }\n    groupedNoteholdings(excludeResolved: true) {\n      totalNotes\n    }\n    groupedPlanData {\n      planType\n      totalGranted\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioDetailsQuery__\n *\n * To run a query within a React component, call `usePortfolioDetailsQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioDetailsQuery({\n *   variables: {\n *      shareholderId: // value for 'shareholderId'\n *   },\n * });\n */\nexport function usePortfolioDetailsQuery(baseOptions?: Apollo.QueryHookOptions<PortfolioDetailsQuery, PortfolioDetailsQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioDetailsQuery, PortfolioDetailsQueryVariables>(PortfolioDetailsDocument, options);\n      }\nexport function usePortfolioDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioDetailsQuery, PortfolioDetailsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioDetailsQuery, PortfolioDetailsQueryVariables>(PortfolioDetailsDocument, options);\n        }\nexport function usePortfolioDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioDetailsQuery, PortfolioDetailsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioDetailsQuery, PortfolioDetailsQueryVariables>(PortfolioDetailsDocument, options);\n        }\nexport type PortfolioDetailsQueryHookResult = ReturnType<typeof usePortfolioDetailsQuery>;\nexport type PortfolioDetailsLazyQueryHookResult = ReturnType<typeof usePortfolioDetailsLazyQuery>;\nexport type PortfolioDetailsSuspenseQueryHookResult = ReturnType<typeof usePortfolioDetailsSuspenseQuery>;\nexport type PortfolioDetailsQueryResult = Apollo.QueryResult<PortfolioDetailsQuery, PortfolioDetailsQueryVariables>;\nexport function refetchPortfolioDetailsQuery(variables?: PortfolioDetailsQueryVariables) {\n      return { query: PortfolioDetailsDocument, variables: variables };\n    }\nexport const PortfolioNoteDetailsDocument: TypedDocumentNode<PortfolioNoteDetailsQuery, PortfolioNoteDetailsQueryVariables> = gql`\n  query PortfolioNoteDetails($shareholderId: UUID!) {\n  shareholderTransactions(shareholderId: $shareholderId) {\n    id\n    displayName\n    avatar\n    organisation {\n      id\n      name\n      logo: logoImageLink\n      currency\n    }\n    noteholdings {\n      transactionId: id\n      transactionDate\n      type\n      note {\n        id\n        type\n        principal\n        interestRate\n        discountRate\n        valuationCap\n        maturityDate\n      }\n    }\n    notes {\n      id\n      type\n      principal\n      interestRate\n      discountRate\n      valuationCap\n      maturityDate\n      resolution\n      issueDate\n    }\n    groupedNoteholdings(excludeResolved: true) {\n      totalNotes\n      totalInvested\n      notetype\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioNoteDetailsQuery__\n *\n * To run a query within a React component, call `usePortfolioNoteDetailsQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioNoteDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioNoteDetailsQuery({\n *   variables: {\n *      shareholderId: // value for 'shareholderId'\n *   },\n * });\n */\nexport function usePortfolioNoteDetailsQuery(baseOptions: Apollo.QueryHookOptions<PortfolioNoteDetailsQuery, PortfolioNoteDetailsQueryVariables> & ({ variables: PortfolioNoteDetailsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioNoteDetailsQuery, PortfolioNoteDetailsQueryVariables>(PortfolioNoteDetailsDocument, options);\n      }\nexport function usePortfolioNoteDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioNoteDetailsQuery, PortfolioNoteDetailsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioNoteDetailsQuery, PortfolioNoteDetailsQueryVariables>(PortfolioNoteDetailsDocument, options);\n        }\nexport function usePortfolioNoteDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioNoteDetailsQuery, PortfolioNoteDetailsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioNoteDetailsQuery, PortfolioNoteDetailsQueryVariables>(PortfolioNoteDetailsDocument, options);\n        }\nexport type PortfolioNoteDetailsQueryHookResult = ReturnType<typeof usePortfolioNoteDetailsQuery>;\nexport type PortfolioNoteDetailsLazyQueryHookResult = ReturnType<typeof usePortfolioNoteDetailsLazyQuery>;\nexport type PortfolioNoteDetailsSuspenseQueryHookResult = ReturnType<typeof usePortfolioNoteDetailsSuspenseQuery>;\nexport type PortfolioNoteDetailsQueryResult = Apollo.QueryResult<PortfolioNoteDetailsQuery, PortfolioNoteDetailsQueryVariables>;\nexport function refetchPortfolioNoteDetailsQuery(variables: PortfolioNoteDetailsQueryVariables) {\n      return { query: PortfolioNoteDetailsDocument, variables: variables };\n    }\nexport const PortfolioOfferDetailsRsuDocument: TypedDocumentNode<PortfolioOfferDetailsRsuQuery, PortfolioOfferDetailsRsuQueryVariables> = gql`\n  query PortfolioOfferDetailsRsu($offerId: UUID!) {\n  rsuOfferDetails(offerId: $offerId) {\n    id\n    shareholder {\n      displayName\n      avatar\n    }\n    group {\n      plan {\n        name\n        organisation {\n          id\n          name\n          logo: logoImageLink\n          currency\n          valuationVisibleToShareholders\n          valuationVisibleToOptionholders\n          ownershipVisibleToShareholders\n          ownershipVisibleToOptionholders\n          fullyDilutedShares\n          totalShares\n          totalSharesUnexercised\n          valuationAt {\n            valuation\n          }\n        }\n      }\n      country\n    }\n    granted\n    vested\n    lapsed\n    exercised\n    transactionSet: rsutransactionSet {\n      type\n      transactionDate\n      vestingValue\n    }\n    rsuvestingeventSet {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: rsutransactionSet {\n        id\n        transactionDate\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n        reminderDate\n      }\n    }\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    offerLetterTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    planRulesTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    offerLetter {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    planRules {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    conversionlockevent: rsuconversionlockevent {\n      description\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioOfferDetailsRsuQuery__\n *\n * To run a query within a React component, call `usePortfolioOfferDetailsRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioOfferDetailsRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioOfferDetailsRsuQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function usePortfolioOfferDetailsRsuQuery(baseOptions: Apollo.QueryHookOptions<PortfolioOfferDetailsRsuQuery, PortfolioOfferDetailsRsuQueryVariables> & ({ variables: PortfolioOfferDetailsRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioOfferDetailsRsuQuery, PortfolioOfferDetailsRsuQueryVariables>(PortfolioOfferDetailsRsuDocument, options);\n      }\nexport function usePortfolioOfferDetailsRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioOfferDetailsRsuQuery, PortfolioOfferDetailsRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioOfferDetailsRsuQuery, PortfolioOfferDetailsRsuQueryVariables>(PortfolioOfferDetailsRsuDocument, options);\n        }\nexport function usePortfolioOfferDetailsRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioOfferDetailsRsuQuery, PortfolioOfferDetailsRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioOfferDetailsRsuQuery, PortfolioOfferDetailsRsuQueryVariables>(PortfolioOfferDetailsRsuDocument, options);\n        }\nexport type PortfolioOfferDetailsRsuQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsRsuQuery>;\nexport type PortfolioOfferDetailsRsuLazyQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsRsuLazyQuery>;\nexport type PortfolioOfferDetailsRsuSuspenseQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsRsuSuspenseQuery>;\nexport type PortfolioOfferDetailsRsuQueryResult = Apollo.QueryResult<PortfolioOfferDetailsRsuQuery, PortfolioOfferDetailsRsuQueryVariables>;\nexport function refetchPortfolioOfferDetailsRsuQuery(variables: PortfolioOfferDetailsRsuQueryVariables) {\n      return { query: PortfolioOfferDetailsRsuDocument, variables: variables };\n    }\nexport const PortfolioOffersListRsuDocument: TypedDocumentNode<PortfolioOffersListRsuQuery, PortfolioOffersListRsuQueryVariables> = gql`\n  query PortfolioOffersListRsu($employee: ShareholderCakeType!) {\n  rsuOfferList(employee: $employee) {\n    id\n    group {\n      id\n      country\n      plan {\n        name\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioOffersListRsuQuery__\n *\n * To run a query within a React component, call `usePortfolioOffersListRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioOffersListRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioOffersListRsuQuery({\n *   variables: {\n *      employee: // value for 'employee'\n *   },\n * });\n */\nexport function usePortfolioOffersListRsuQuery(baseOptions: Apollo.QueryHookOptions<PortfolioOffersListRsuQuery, PortfolioOffersListRsuQueryVariables> & ({ variables: PortfolioOffersListRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioOffersListRsuQuery, PortfolioOffersListRsuQueryVariables>(PortfolioOffersListRsuDocument, options);\n      }\nexport function usePortfolioOffersListRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioOffersListRsuQuery, PortfolioOffersListRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioOffersListRsuQuery, PortfolioOffersListRsuQueryVariables>(PortfolioOffersListRsuDocument, options);\n        }\nexport function usePortfolioOffersListRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioOffersListRsuQuery, PortfolioOffersListRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioOffersListRsuQuery, PortfolioOffersListRsuQueryVariables>(PortfolioOffersListRsuDocument, options);\n        }\nexport type PortfolioOffersListRsuQueryHookResult = ReturnType<typeof usePortfolioOffersListRsuQuery>;\nexport type PortfolioOffersListRsuLazyQueryHookResult = ReturnType<typeof usePortfolioOffersListRsuLazyQuery>;\nexport type PortfolioOffersListRsuSuspenseQueryHookResult = ReturnType<typeof usePortfolioOffersListRsuSuspenseQuery>;\nexport type PortfolioOffersListRsuQueryResult = Apollo.QueryResult<PortfolioOffersListRsuQuery, PortfolioOffersListRsuQueryVariables>;\nexport function refetchPortfolioOffersListRsuQuery(variables: PortfolioOffersListRsuQueryVariables) {\n      return { query: PortfolioOffersListRsuDocument, variables: variables };\n    }\nexport const PortfolioOfferDetailsWarrantDocument: TypedDocumentNode<PortfolioOfferDetailsWarrantQuery, PortfolioOfferDetailsWarrantQueryVariables> = gql`\n  query PortfolioOfferDetailsWarrant($offerId: UUID!) {\n  warrantOfferDetails(offerId: $offerId) {\n    id\n    shareholder {\n      displayName\n      avatar\n    }\n    group {\n      plan {\n        name\n        organisation {\n          id\n          name\n          logo: logoImageLink\n          currency\n          valuationVisibleToShareholders\n          valuationVisibleToOptionholders\n          ownershipVisibleToShareholders\n          ownershipVisibleToOptionholders\n          fullyDilutedShares\n          totalShares\n          totalSharesUnexercised\n          valuationAt {\n            valuation\n          }\n        }\n      }\n      country\n    }\n    granted\n    vested\n    lapsed\n    exercised\n    transactionSet: warranttransactionSet {\n      type\n      transactionDate\n      vestingValue\n    }\n    warrantvestingeventSet {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: warranttransactionSet {\n        id\n        transactionDate\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n        reminderDate\n      }\n    }\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        lapsed\n        entryType\n        transactionId\n      }\n      vestStartDate\n    }\n    offerLetterTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    planRulesTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    offerLetter {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n    planRules {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioOfferDetailsWarrantQuery__\n *\n * To run a query within a React component, call `usePortfolioOfferDetailsWarrantQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioOfferDetailsWarrantQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioOfferDetailsWarrantQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function usePortfolioOfferDetailsWarrantQuery(baseOptions: Apollo.QueryHookOptions<PortfolioOfferDetailsWarrantQuery, PortfolioOfferDetailsWarrantQueryVariables> & ({ variables: PortfolioOfferDetailsWarrantQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioOfferDetailsWarrantQuery, PortfolioOfferDetailsWarrantQueryVariables>(PortfolioOfferDetailsWarrantDocument, options);\n      }\nexport function usePortfolioOfferDetailsWarrantLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioOfferDetailsWarrantQuery, PortfolioOfferDetailsWarrantQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioOfferDetailsWarrantQuery, PortfolioOfferDetailsWarrantQueryVariables>(PortfolioOfferDetailsWarrantDocument, options);\n        }\nexport function usePortfolioOfferDetailsWarrantSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioOfferDetailsWarrantQuery, PortfolioOfferDetailsWarrantQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioOfferDetailsWarrantQuery, PortfolioOfferDetailsWarrantQueryVariables>(PortfolioOfferDetailsWarrantDocument, options);\n        }\nexport type PortfolioOfferDetailsWarrantQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsWarrantQuery>;\nexport type PortfolioOfferDetailsWarrantLazyQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsWarrantLazyQuery>;\nexport type PortfolioOfferDetailsWarrantSuspenseQueryHookResult = ReturnType<typeof usePortfolioOfferDetailsWarrantSuspenseQuery>;\nexport type PortfolioOfferDetailsWarrantQueryResult = Apollo.QueryResult<PortfolioOfferDetailsWarrantQuery, PortfolioOfferDetailsWarrantQueryVariables>;\nexport function refetchPortfolioOfferDetailsWarrantQuery(variables: PortfolioOfferDetailsWarrantQueryVariables) {\n      return { query: PortfolioOfferDetailsWarrantDocument, variables: variables };\n    }\nexport const PortfolioOffersListWarrantDocument: TypedDocumentNode<PortfolioOffersListWarrantQuery, PortfolioOffersListWarrantQueryVariables> = gql`\n  query PortfolioOffersListWarrant($employee: ShareholderCakeType!) {\n  warrantOfferList(employee: $employee) {\n    id\n    group {\n      id\n      country\n      plan {\n        name\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __usePortfolioOffersListWarrantQuery__\n *\n * To run a query within a React component, call `usePortfolioOffersListWarrantQuery` and pass it any options that fit your needs.\n * When your component renders, `usePortfolioOffersListWarrantQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePortfolioOffersListWarrantQuery({\n *   variables: {\n *      employee: // value for 'employee'\n *   },\n * });\n */\nexport function usePortfolioOffersListWarrantQuery(baseOptions: Apollo.QueryHookOptions<PortfolioOffersListWarrantQuery, PortfolioOffersListWarrantQueryVariables> & ({ variables: PortfolioOffersListWarrantQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PortfolioOffersListWarrantQuery, PortfolioOffersListWarrantQueryVariables>(PortfolioOffersListWarrantDocument, options);\n      }\nexport function usePortfolioOffersListWarrantLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioOffersListWarrantQuery, PortfolioOffersListWarrantQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PortfolioOffersListWarrantQuery, PortfolioOffersListWarrantQueryVariables>(PortfolioOffersListWarrantDocument, options);\n        }\nexport function usePortfolioOffersListWarrantSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PortfolioOffersListWarrantQuery, PortfolioOffersListWarrantQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PortfolioOffersListWarrantQuery, PortfolioOffersListWarrantQueryVariables>(PortfolioOffersListWarrantDocument, options);\n        }\nexport type PortfolioOffersListWarrantQueryHookResult = ReturnType<typeof usePortfolioOffersListWarrantQuery>;\nexport type PortfolioOffersListWarrantLazyQueryHookResult = ReturnType<typeof usePortfolioOffersListWarrantLazyQuery>;\nexport type PortfolioOffersListWarrantSuspenseQueryHookResult = ReturnType<typeof usePortfolioOffersListWarrantSuspenseQuery>;\nexport type PortfolioOffersListWarrantQueryResult = Apollo.QueryResult<PortfolioOffersListWarrantQuery, PortfolioOffersListWarrantQueryVariables>;\nexport function refetchPortfolioOffersListWarrantQuery(variables: PortfolioOffersListWarrantQueryVariables) {\n      return { query: PortfolioOffersListWarrantDocument, variables: variables };\n    }\nexport const UserProfileDocument: TypedDocumentNode<UserProfileQuery, UserProfileQueryVariables> = gql`\n  query userProfile {\n  userProfile {\n    name\n    email\n    picture\n  }\n}\n    `;\n\n/**\n * __useUserProfileQuery__\n *\n * To run a query within a React component, call `useUserProfileQuery` and pass it any options that fit your needs.\n * When your component renders, `useUserProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useUserProfileQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useUserProfileQuery(baseOptions?: Apollo.QueryHookOptions<UserProfileQuery, UserProfileQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);\n      }\nexport function useUserProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);\n        }\nexport function useUserProfileSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);\n        }\nexport type UserProfileQueryHookResult = ReturnType<typeof useUserProfileQuery>;\nexport type UserProfileLazyQueryHookResult = ReturnType<typeof useUserProfileLazyQuery>;\nexport type UserProfileSuspenseQueryHookResult = ReturnType<typeof useUserProfileSuspenseQuery>;\nexport type UserProfileQueryResult = Apollo.QueryResult<UserProfileQuery, UserProfileQueryVariables>;\nexport function refetchUserProfileQuery(variables?: UserProfileQueryVariables) {\n      return { query: UserProfileDocument, variables: variables };\n    }\nexport const CanChangeEmailDocument: TypedDocumentNode<CanChangeEmailQuery, CanChangeEmailQueryVariables> = gql`\n  query canChangeEmail {\n  canChangeEmail\n}\n    `;\n\n/**\n * __useCanChangeEmailQuery__\n *\n * To run a query within a React component, call `useCanChangeEmailQuery` and pass it any options that fit your needs.\n * When your component renders, `useCanChangeEmailQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCanChangeEmailQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useCanChangeEmailQuery(baseOptions?: Apollo.QueryHookOptions<CanChangeEmailQuery, CanChangeEmailQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<CanChangeEmailQuery, CanChangeEmailQueryVariables>(CanChangeEmailDocument, options);\n      }\nexport function useCanChangeEmailLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CanChangeEmailQuery, CanChangeEmailQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<CanChangeEmailQuery, CanChangeEmailQueryVariables>(CanChangeEmailDocument, options);\n        }\nexport function useCanChangeEmailSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<CanChangeEmailQuery, CanChangeEmailQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<CanChangeEmailQuery, CanChangeEmailQueryVariables>(CanChangeEmailDocument, options);\n        }\nexport type CanChangeEmailQueryHookResult = ReturnType<typeof useCanChangeEmailQuery>;\nexport type CanChangeEmailLazyQueryHookResult = ReturnType<typeof useCanChangeEmailLazyQuery>;\nexport type CanChangeEmailSuspenseQueryHookResult = ReturnType<typeof useCanChangeEmailSuspenseQuery>;\nexport type CanChangeEmailQueryResult = Apollo.QueryResult<CanChangeEmailQuery, CanChangeEmailQueryVariables>;\nexport function refetchCanChangeEmailQuery(variables?: CanChangeEmailQueryVariables) {\n      return { query: CanChangeEmailDocument, variables: variables };\n    }\nexport const UserSettingsDocument: TypedDocumentNode<UserSettingsQuery, UserSettingsQueryVariables> = gql`\n  query userSettings {\n  userSettings {\n    currency\n  }\n}\n    `;\n\n/**\n * __useUserSettingsQuery__\n *\n * To run a query within a React component, call `useUserSettingsQuery` and pass it any options that fit your needs.\n * When your component renders, `useUserSettingsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useUserSettingsQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useUserSettingsQuery(baseOptions?: Apollo.QueryHookOptions<UserSettingsQuery, UserSettingsQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<UserSettingsQuery, UserSettingsQueryVariables>(UserSettingsDocument, options);\n      }\nexport function useUserSettingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UserSettingsQuery, UserSettingsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<UserSettingsQuery, UserSettingsQueryVariables>(UserSettingsDocument, options);\n        }\nexport function useUserSettingsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserSettingsQuery, UserSettingsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<UserSettingsQuery, UserSettingsQueryVariables>(UserSettingsDocument, options);\n        }\nexport type UserSettingsQueryHookResult = ReturnType<typeof useUserSettingsQuery>;\nexport type UserSettingsLazyQueryHookResult = ReturnType<typeof useUserSettingsLazyQuery>;\nexport type UserSettingsSuspenseQueryHookResult = ReturnType<typeof useUserSettingsSuspenseQuery>;\nexport type UserSettingsQueryResult = Apollo.QueryResult<UserSettingsQuery, UserSettingsQueryVariables>;\nexport function refetchUserSettingsQuery(variables?: UserSettingsQueryVariables) {\n      return { query: UserSettingsDocument, variables: variables };\n    }\nexport const SkipUserOnboardingDocument: TypedDocumentNode<SkipUserOnboardingMutation, SkipUserOnboardingMutationVariables> = gql`\n  mutation skipUserOnboarding {\n  skipUserOnboarding\n}\n    `;\nexport type SkipUserOnboardingMutationFn = Apollo.MutationFunction<SkipUserOnboardingMutation, SkipUserOnboardingMutationVariables>;\n\n/**\n * __useSkipUserOnboardingMutation__\n *\n * To run a mutation, you first call `useSkipUserOnboardingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSkipUserOnboardingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [skipUserOnboardingMutation, { data, loading, error }] = useSkipUserOnboardingMutation({\n *   variables: {\n *   },\n * });\n */\nexport function useSkipUserOnboardingMutation(baseOptions?: Apollo.MutationHookOptions<SkipUserOnboardingMutation, SkipUserOnboardingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SkipUserOnboardingMutation, SkipUserOnboardingMutationVariables>(SkipUserOnboardingDocument, options);\n      }\nexport type SkipUserOnboardingMutationHookResult = ReturnType<typeof useSkipUserOnboardingMutation>;\nexport type SkipUserOnboardingMutationResult = Apollo.MutationResult<SkipUserOnboardingMutation>;\nexport type SkipUserOnboardingMutationOptions = Apollo.BaseMutationOptions<SkipUserOnboardingMutation, SkipUserOnboardingMutationVariables>;\nexport const RequestEmailChangeDocument: TypedDocumentNode<RequestEmailChangeMutation, RequestEmailChangeMutationVariables> = gql`\n  mutation requestEmailChange($newEmail: CleanString!) {\n  requestEmailChange(newEmail: $newEmail)\n}\n    `;\nexport type RequestEmailChangeMutationFn = Apollo.MutationFunction<RequestEmailChangeMutation, RequestEmailChangeMutationVariables>;\n\n/**\n * __useRequestEmailChangeMutation__\n *\n * To run a mutation, you first call `useRequestEmailChangeMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRequestEmailChangeMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [requestEmailChangeMutation, { data, loading, error }] = useRequestEmailChangeMutation({\n *   variables: {\n *      newEmail: // value for 'newEmail'\n *   },\n * });\n */\nexport function useRequestEmailChangeMutation(baseOptions?: Apollo.MutationHookOptions<RequestEmailChangeMutation, RequestEmailChangeMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RequestEmailChangeMutation, RequestEmailChangeMutationVariables>(RequestEmailChangeDocument, options);\n      }\nexport type RequestEmailChangeMutationHookResult = ReturnType<typeof useRequestEmailChangeMutation>;\nexport type RequestEmailChangeMutationResult = Apollo.MutationResult<RequestEmailChangeMutation>;\nexport type RequestEmailChangeMutationOptions = Apollo.BaseMutationOptions<RequestEmailChangeMutation, RequestEmailChangeMutationVariables>;\nexport const UpdateUserOnboardingDocument: TypedDocumentNode<UpdateUserOnboardingMutation, UpdateUserOnboardingMutationVariables> = gql`\n  mutation updateUserOnboarding($userBackground: [CleanString!]!, $intents: [CleanString!]!, $currency: CleanString) {\n  updateUserOnboarding(\n    userBackground: $userBackground\n    intents: $intents\n    currency: $currency\n  )\n}\n    `;\nexport type UpdateUserOnboardingMutationFn = Apollo.MutationFunction<UpdateUserOnboardingMutation, UpdateUserOnboardingMutationVariables>;\n\n/**\n * __useUpdateUserOnboardingMutation__\n *\n * To run a mutation, you first call `useUpdateUserOnboardingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateUserOnboardingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateUserOnboardingMutation, { data, loading, error }] = useUpdateUserOnboardingMutation({\n *   variables: {\n *      userBackground: // value for 'userBackground'\n *      intents: // value for 'intents'\n *      currency: // value for 'currency'\n *   },\n * });\n */\nexport function useUpdateUserOnboardingMutation(baseOptions?: Apollo.MutationHookOptions<UpdateUserOnboardingMutation, UpdateUserOnboardingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateUserOnboardingMutation, UpdateUserOnboardingMutationVariables>(UpdateUserOnboardingDocument, options);\n      }\nexport type UpdateUserOnboardingMutationHookResult = ReturnType<typeof useUpdateUserOnboardingMutation>;\nexport type UpdateUserOnboardingMutationResult = Apollo.MutationResult<UpdateUserOnboardingMutation>;\nexport type UpdateUserOnboardingMutationOptions = Apollo.BaseMutationOptions<UpdateUserOnboardingMutation, UpdateUserOnboardingMutationVariables>;\nexport const UpdateUserSettingsDocument: TypedDocumentNode<UpdateUserSettingsMutation, UpdateUserSettingsMutationVariables> = gql`\n  mutation updateUserSettings($currency: CleanString!) {\n  updateUserSettings(currency: $currency)\n}\n    `;\nexport type UpdateUserSettingsMutationFn = Apollo.MutationFunction<UpdateUserSettingsMutation, UpdateUserSettingsMutationVariables>;\n\n/**\n * __useUpdateUserSettingsMutation__\n *\n * To run a mutation, you first call `useUpdateUserSettingsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateUserSettingsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateUserSettingsMutation, { data, loading, error }] = useUpdateUserSettingsMutation({\n *   variables: {\n *      currency: // value for 'currency'\n *   },\n * });\n */\nexport function useUpdateUserSettingsMutation(baseOptions?: Apollo.MutationHookOptions<UpdateUserSettingsMutation, UpdateUserSettingsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateUserSettingsMutation, UpdateUserSettingsMutationVariables>(UpdateUserSettingsDocument, options);\n      }\nexport type UpdateUserSettingsMutationHookResult = ReturnType<typeof useUpdateUserSettingsMutation>;\nexport type UpdateUserSettingsMutationResult = Apollo.MutationResult<UpdateUserSettingsMutation>;\nexport type UpdateUserSettingsMutationOptions = Apollo.BaseMutationOptions<UpdateUserSettingsMutation, UpdateUserSettingsMutationVariables>;\nexport const AcceptTermsAndConditionsDocument: TypedDocumentNode<AcceptTermsAndConditionsMutation, AcceptTermsAndConditionsMutationVariables> = gql`\n  mutation acceptTermsAndConditions {\n  acceptTermsAndConditions\n}\n    `;\nexport type AcceptTermsAndConditionsMutationFn = Apollo.MutationFunction<AcceptTermsAndConditionsMutation, AcceptTermsAndConditionsMutationVariables>;\n\n/**\n * __useAcceptTermsAndConditionsMutation__\n *\n * To run a mutation, you first call `useAcceptTermsAndConditionsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAcceptTermsAndConditionsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [acceptTermsAndConditionsMutation, { data, loading, error }] = useAcceptTermsAndConditionsMutation({\n *   variables: {\n *   },\n * });\n */\nexport function useAcceptTermsAndConditionsMutation(baseOptions?: Apollo.MutationHookOptions<AcceptTermsAndConditionsMutation, AcceptTermsAndConditionsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AcceptTermsAndConditionsMutation, AcceptTermsAndConditionsMutationVariables>(AcceptTermsAndConditionsDocument, options);\n      }\nexport type AcceptTermsAndConditionsMutationHookResult = ReturnType<typeof useAcceptTermsAndConditionsMutation>;\nexport type AcceptTermsAndConditionsMutationResult = Apollo.MutationResult<AcceptTermsAndConditionsMutation>;\nexport type AcceptTermsAndConditionsMutationOptions = Apollo.BaseMutationOptions<AcceptTermsAndConditionsMutation, AcceptTermsAndConditionsMutationVariables>;\nexport const ShareholderDetailsDocument: TypedDocumentNode<ShareholderDetailsQuery, ShareholderDetailsQueryVariables> = gql`\n  query shareholderDetails($shareholderId: UUID!) {\n  shareholder: shareholderTransactions(shareholderId: $shareholderId) {\n    id\n    computedType\n    heldInTrust\n    trustName\n    trustAbn\n    displayName\n    avatar\n    investorData {\n      name\n      email\n      phone\n      jointIndex\n      address {\n        line1\n        line2\n        locality\n        administrativeArea1\n        postcode\n        country\n      }\n      shareholder {\n        id\n      }\n      companyData {\n        contactPerson\n        identifierType\n        identifierNumber\n        signers {\n          name\n          email\n          role\n        }\n      }\n    }\n    recipient {\n      id\n      displayName\n      avatar\n      trustAbn\n      heldInTrust\n      trustName\n      computedType\n      investorData {\n        name\n        email\n        phone\n        jointIndex\n        address {\n          line2\n          line1\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n        companyData {\n          contactPerson\n          identifierType\n          identifierNumber\n          signers {\n            name\n            email\n            role\n          }\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useShareholderDetailsQuery__\n *\n * To run a query within a React component, call `useShareholderDetailsQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareholderDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareholderDetailsQuery({\n *   variables: {\n *      shareholderId: // value for 'shareholderId'\n *   },\n * });\n */\nexport function useShareholderDetailsQuery(baseOptions: Apollo.QueryHookOptions<ShareholderDetailsQuery, ShareholderDetailsQueryVariables> & ({ variables: ShareholderDetailsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareholderDetailsQuery, ShareholderDetailsQueryVariables>(ShareholderDetailsDocument, options);\n      }\nexport function useShareholderDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareholderDetailsQuery, ShareholderDetailsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareholderDetailsQuery, ShareholderDetailsQueryVariables>(ShareholderDetailsDocument, options);\n        }\nexport function useShareholderDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareholderDetailsQuery, ShareholderDetailsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareholderDetailsQuery, ShareholderDetailsQueryVariables>(ShareholderDetailsDocument, options);\n        }\nexport type ShareholderDetailsQueryHookResult = ReturnType<typeof useShareholderDetailsQuery>;\nexport type ShareholderDetailsLazyQueryHookResult = ReturnType<typeof useShareholderDetailsLazyQuery>;\nexport type ShareholderDetailsSuspenseQueryHookResult = ReturnType<typeof useShareholderDetailsSuspenseQuery>;\nexport type ShareholderDetailsQueryResult = Apollo.QueryResult<ShareholderDetailsQuery, ShareholderDetailsQueryVariables>;\nexport function refetchShareholderDetailsQuery(variables: ShareholderDetailsQueryVariables) {\n      return { query: ShareholderDetailsDocument, variables: variables };\n    }\nexport const GetActionsDocument: TypedDocumentNode<GetActionsQuery, GetActionsQueryVariables> = gql`\n  query getActions($organisationId: OrganisationCakeType!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger) {\n  actionItems(\n    organisation: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    recent\n    pageData {\n      shDisplayName\n      recent\n      description\n      link\n      snooze\n      itemDate\n      actionableId\n      actionType\n    }\n  }\n}\n    `;\n\n/**\n * __useGetActionsQuery__\n *\n * To run a query within a React component, call `useGetActionsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetActionsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetActionsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetActionsQuery(baseOptions: Apollo.QueryHookOptions<GetActionsQuery, GetActionsQueryVariables> & ({ variables: GetActionsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetActionsQuery, GetActionsQueryVariables>(GetActionsDocument, options);\n      }\nexport function useGetActionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetActionsQuery, GetActionsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetActionsQuery, GetActionsQueryVariables>(GetActionsDocument, options);\n        }\nexport function useGetActionsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetActionsQuery, GetActionsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetActionsQuery, GetActionsQueryVariables>(GetActionsDocument, options);\n        }\nexport type GetActionsQueryHookResult = ReturnType<typeof useGetActionsQuery>;\nexport type GetActionsLazyQueryHookResult = ReturnType<typeof useGetActionsLazyQuery>;\nexport type GetActionsSuspenseQueryHookResult = ReturnType<typeof useGetActionsSuspenseQuery>;\nexport type GetActionsQueryResult = Apollo.QueryResult<GetActionsQuery, GetActionsQueryVariables>;\nexport function refetchGetActionsQuery(variables: GetActionsQueryVariables) {\n      return { query: GetActionsDocument, variables: variables };\n    }\nexport const GetReminderEmailDocument: TypedDocumentNode<GetReminderEmailQuery, GetReminderEmailQueryVariables> = gql`\n  query getReminderEmail($offerId: UUID!) {\n  getReminderEmail(offerId: $offerId) {\n    subject\n    body\n    recipientName\n    recipientEmail\n  }\n}\n    `;\n\n/**\n * __useGetReminderEmailQuery__\n *\n * To run a query within a React component, call `useGetReminderEmailQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetReminderEmailQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetReminderEmailQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useGetReminderEmailQuery(baseOptions: Apollo.QueryHookOptions<GetReminderEmailQuery, GetReminderEmailQueryVariables> & ({ variables: GetReminderEmailQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetReminderEmailQuery, GetReminderEmailQueryVariables>(GetReminderEmailDocument, options);\n      }\nexport function useGetReminderEmailLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetReminderEmailQuery, GetReminderEmailQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetReminderEmailQuery, GetReminderEmailQueryVariables>(GetReminderEmailDocument, options);\n        }\nexport function useGetReminderEmailSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetReminderEmailQuery, GetReminderEmailQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetReminderEmailQuery, GetReminderEmailQueryVariables>(GetReminderEmailDocument, options);\n        }\nexport type GetReminderEmailQueryHookResult = ReturnType<typeof useGetReminderEmailQuery>;\nexport type GetReminderEmailLazyQueryHookResult = ReturnType<typeof useGetReminderEmailLazyQuery>;\nexport type GetReminderEmailSuspenseQueryHookResult = ReturnType<typeof useGetReminderEmailSuspenseQuery>;\nexport type GetReminderEmailQueryResult = Apollo.QueryResult<GetReminderEmailQuery, GetReminderEmailQueryVariables>;\nexport function refetchGetReminderEmailQuery(variables: GetReminderEmailQueryVariables) {\n      return { query: GetReminderEmailDocument, variables: variables };\n    }\nexport const RemindAllOffersDocument: TypedDocumentNode<RemindAllOffersMutation, RemindAllOffersMutationVariables> = gql`\n  mutation remindAllOffers($organisation: OrganisationCakeType!) {\n  remindAllOffers(organisation: $organisation)\n}\n    `;\nexport type RemindAllOffersMutationFn = Apollo.MutationFunction<RemindAllOffersMutation, RemindAllOffersMutationVariables>;\n\n/**\n * __useRemindAllOffersMutation__\n *\n * To run a mutation, you first call `useRemindAllOffersMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRemindAllOffersMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [remindAllOffersMutation, { data, loading, error }] = useRemindAllOffersMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useRemindAllOffersMutation(baseOptions?: Apollo.MutationHookOptions<RemindAllOffersMutation, RemindAllOffersMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RemindAllOffersMutation, RemindAllOffersMutationVariables>(RemindAllOffersDocument, options);\n      }\nexport type RemindAllOffersMutationHookResult = ReturnType<typeof useRemindAllOffersMutation>;\nexport type RemindAllOffersMutationResult = Apollo.MutationResult<RemindAllOffersMutation>;\nexport type RemindAllOffersMutationOptions = Apollo.BaseMutationOptions<RemindAllOffersMutation, RemindAllOffersMutationVariables>;\nexport const TouchOffersDocument: TypedDocumentNode<TouchOffersMutation, TouchOffersMutationVariables> = gql`\n  mutation touchOffers($offers: [UUID!]!, $nudge: Boolean) {\n  touchOffers(offerIds: $offers, remind: $nudge)\n}\n    `;\nexport type TouchOffersMutationFn = Apollo.MutationFunction<TouchOffersMutation, TouchOffersMutationVariables>;\n\n/**\n * __useTouchOffersMutation__\n *\n * To run a mutation, you first call `useTouchOffersMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useTouchOffersMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [touchOffersMutation, { data, loading, error }] = useTouchOffersMutation({\n *   variables: {\n *      offers: // value for 'offers'\n *      nudge: // value for 'nudge'\n *   },\n * });\n */\nexport function useTouchOffersMutation(baseOptions?: Apollo.MutationHookOptions<TouchOffersMutation, TouchOffersMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<TouchOffersMutation, TouchOffersMutationVariables>(TouchOffersDocument, options);\n      }\nexport type TouchOffersMutationHookResult = ReturnType<typeof useTouchOffersMutation>;\nexport type TouchOffersMutationResult = Apollo.MutationResult<TouchOffersMutation>;\nexport type TouchOffersMutationOptions = Apollo.BaseMutationOptions<TouchOffersMutation, TouchOffersMutationVariables>;\nexport const GetActivityLogEntriesDocument: TypedDocumentNode<GetActivityLogEntriesQuery, GetActivityLogEntriesQueryVariables> = gql`\n  query getActivityLogEntries($organisationId: OrganisationCakeType!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $search: CleanString, $showSupportAdmin: Boolean) {\n  activityLogEntries(\n    organisation: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    search: $search\n    showSupportAdmin: $showSupportAdmin\n  ) {\n    pageData {\n      organisation {\n        name\n      }\n      user {\n        email\n        name\n        picture\n      }\n      timestamp\n      name\n      payload\n      duration\n      supportAdminOnly\n    }\n    currentPage\n    count\n  }\n  activityLogContextNames(organisation: $organisationId)\n}\n    `;\n\n/**\n * __useGetActivityLogEntriesQuery__\n *\n * To run a query within a React component, call `useGetActivityLogEntriesQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetActivityLogEntriesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetActivityLogEntriesQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      search: // value for 'search'\n *      showSupportAdmin: // value for 'showSupportAdmin'\n *   },\n * });\n */\nexport function useGetActivityLogEntriesQuery(baseOptions: Apollo.QueryHookOptions<GetActivityLogEntriesQuery, GetActivityLogEntriesQueryVariables> & ({ variables: GetActivityLogEntriesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetActivityLogEntriesQuery, GetActivityLogEntriesQueryVariables>(GetActivityLogEntriesDocument, options);\n      }\nexport function useGetActivityLogEntriesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetActivityLogEntriesQuery, GetActivityLogEntriesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetActivityLogEntriesQuery, GetActivityLogEntriesQueryVariables>(GetActivityLogEntriesDocument, options);\n        }\nexport function useGetActivityLogEntriesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetActivityLogEntriesQuery, GetActivityLogEntriesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetActivityLogEntriesQuery, GetActivityLogEntriesQueryVariables>(GetActivityLogEntriesDocument, options);\n        }\nexport type GetActivityLogEntriesQueryHookResult = ReturnType<typeof useGetActivityLogEntriesQuery>;\nexport type GetActivityLogEntriesLazyQueryHookResult = ReturnType<typeof useGetActivityLogEntriesLazyQuery>;\nexport type GetActivityLogEntriesSuspenseQueryHookResult = ReturnType<typeof useGetActivityLogEntriesSuspenseQuery>;\nexport type GetActivityLogEntriesQueryResult = Apollo.QueryResult<GetActivityLogEntriesQuery, GetActivityLogEntriesQueryVariables>;\nexport function refetchGetActivityLogEntriesQuery(variables: GetActivityLogEntriesQueryVariables) {\n      return { query: GetActivityLogEntriesDocument, variables: variables };\n    }\nexport const GetInvoicesDocument: TypedDocumentNode<GetInvoicesQuery, GetInvoicesQueryVariables> = gql`\n  query getInvoices($organisationId: OrganisationCakeType!) {\n  getInvoices(organisation: $organisationId) {\n    date\n    description\n    total\n    isPaid\n    invoice\n    currency\n  }\n}\n    `;\n\n/**\n * __useGetInvoicesQuery__\n *\n * To run a query within a React component, call `useGetInvoicesQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetInvoicesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetInvoicesQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetInvoicesQuery(baseOptions: Apollo.QueryHookOptions<GetInvoicesQuery, GetInvoicesQueryVariables> & ({ variables: GetInvoicesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetInvoicesQuery, GetInvoicesQueryVariables>(GetInvoicesDocument, options);\n      }\nexport function useGetInvoicesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetInvoicesQuery, GetInvoicesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetInvoicesQuery, GetInvoicesQueryVariables>(GetInvoicesDocument, options);\n        }\nexport function useGetInvoicesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetInvoicesQuery, GetInvoicesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetInvoicesQuery, GetInvoicesQueryVariables>(GetInvoicesDocument, options);\n        }\nexport type GetInvoicesQueryHookResult = ReturnType<typeof useGetInvoicesQuery>;\nexport type GetInvoicesLazyQueryHookResult = ReturnType<typeof useGetInvoicesLazyQuery>;\nexport type GetInvoicesSuspenseQueryHookResult = ReturnType<typeof useGetInvoicesSuspenseQuery>;\nexport type GetInvoicesQueryResult = Apollo.QueryResult<GetInvoicesQuery, GetInvoicesQueryVariables>;\nexport function refetchGetInvoicesQuery(variables: GetInvoicesQueryVariables) {\n      return { query: GetInvoicesDocument, variables: variables };\n    }\nexport const GetLicenseForBillingDocument: TypedDocumentNode<GetLicenseForBillingQuery, GetLicenseForBillingQueryVariables> = gql`\n  query getLicenseForBilling($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    license {\n      overrideDelinquentLock\n      esopOfferCount\n      essOfferCount\n      rsuOfferCount\n      warrantOfferCount\n      esopCount\n      essCount\n      rsuCount\n      equityRaiseCount\n      hasEquityPlansEnabled\n      internalId\n      maxInvestors\n      investorCount\n      delinquent\n      ccLast4\n      globalEsopEnabled\n      isPaused\n      startDate\n      gtCountries\n      billingEmail\n      billingMobile\n      hasActivePurchased409a\n      hasActivePurchasedQsbs\n      showExpired409aBanner\n      hasScanbotDocuments\n      override2faLock\n      renewalDate\n      invalidSince\n      subscriptionCancelDate\n    }\n    scheduledForDeletion\n    userRoles {\n      role\n    }\n  }\n}\n    `;\n\n/**\n * __useGetLicenseForBillingQuery__\n *\n * To run a query within a React component, call `useGetLicenseForBillingQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetLicenseForBillingQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetLicenseForBillingQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetLicenseForBillingQuery(baseOptions: Apollo.QueryHookOptions<GetLicenseForBillingQuery, GetLicenseForBillingQueryVariables> & ({ variables: GetLicenseForBillingQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetLicenseForBillingQuery, GetLicenseForBillingQueryVariables>(GetLicenseForBillingDocument, options);\n      }\nexport function useGetLicenseForBillingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetLicenseForBillingQuery, GetLicenseForBillingQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetLicenseForBillingQuery, GetLicenseForBillingQueryVariables>(GetLicenseForBillingDocument, options);\n        }\nexport function useGetLicenseForBillingSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetLicenseForBillingQuery, GetLicenseForBillingQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetLicenseForBillingQuery, GetLicenseForBillingQueryVariables>(GetLicenseForBillingDocument, options);\n        }\nexport type GetLicenseForBillingQueryHookResult = ReturnType<typeof useGetLicenseForBillingQuery>;\nexport type GetLicenseForBillingLazyQueryHookResult = ReturnType<typeof useGetLicenseForBillingLazyQuery>;\nexport type GetLicenseForBillingSuspenseQueryHookResult = ReturnType<typeof useGetLicenseForBillingSuspenseQuery>;\nexport type GetLicenseForBillingQueryResult = Apollo.QueryResult<GetLicenseForBillingQuery, GetLicenseForBillingQueryVariables>;\nexport function refetchGetLicenseForBillingQuery(variables: GetLicenseForBillingQueryVariables) {\n      return { query: GetLicenseForBillingDocument, variables: variables };\n    }\nexport const GetBillingStakeholdersDocument: TypedDocumentNode<GetBillingStakeholdersQuery, GetBillingStakeholdersQueryVariables> = gql`\n  query getBillingStakeholders($organisationId: OrganisationCakeType!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!) {\n  billingStakeholders(\n    organisation: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    currentPage\n    count\n    pageData {\n      id\n      displayName\n      isShareholder\n      isBeneficiary\n      isNoteholder\n      hasActiveEquityRaiseOffer\n      hasActiveNotesRaiseOffer\n      hasActiveEsopOffer\n      hasActiveEssOffer\n      hasActiveRsuOffer\n    }\n  }\n}\n    `;\n\n/**\n * __useGetBillingStakeholdersQuery__\n *\n * To run a query within a React component, call `useGetBillingStakeholdersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetBillingStakeholdersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetBillingStakeholdersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetBillingStakeholdersQuery(baseOptions: Apollo.QueryHookOptions<GetBillingStakeholdersQuery, GetBillingStakeholdersQueryVariables> & ({ variables: GetBillingStakeholdersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetBillingStakeholdersQuery, GetBillingStakeholdersQueryVariables>(GetBillingStakeholdersDocument, options);\n      }\nexport function useGetBillingStakeholdersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetBillingStakeholdersQuery, GetBillingStakeholdersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetBillingStakeholdersQuery, GetBillingStakeholdersQueryVariables>(GetBillingStakeholdersDocument, options);\n        }\nexport function useGetBillingStakeholdersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetBillingStakeholdersQuery, GetBillingStakeholdersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetBillingStakeholdersQuery, GetBillingStakeholdersQueryVariables>(GetBillingStakeholdersDocument, options);\n        }\nexport type GetBillingStakeholdersQueryHookResult = ReturnType<typeof useGetBillingStakeholdersQuery>;\nexport type GetBillingStakeholdersLazyQueryHookResult = ReturnType<typeof useGetBillingStakeholdersLazyQuery>;\nexport type GetBillingStakeholdersSuspenseQueryHookResult = ReturnType<typeof useGetBillingStakeholdersSuspenseQuery>;\nexport type GetBillingStakeholdersQueryResult = Apollo.QueryResult<GetBillingStakeholdersQuery, GetBillingStakeholdersQueryVariables>;\nexport function refetchGetBillingStakeholdersQuery(variables: GetBillingStakeholdersQueryVariables) {\n      return { query: GetBillingStakeholdersDocument, variables: variables };\n    }\nexport const OverrideDelinquentLockDocument: TypedDocumentNode<OverrideDelinquentLockMutation, OverrideDelinquentLockMutationVariables> = gql`\n  mutation overrideDelinquentLock($organisationId: OrganisationCakeType!, $override: Boolean!) {\n  overrideDelinquentLock(organisation: $organisationId, override: $override)\n}\n    `;\nexport type OverrideDelinquentLockMutationFn = Apollo.MutationFunction<OverrideDelinquentLockMutation, OverrideDelinquentLockMutationVariables>;\n\n/**\n * __useOverrideDelinquentLockMutation__\n *\n * To run a mutation, you first call `useOverrideDelinquentLockMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useOverrideDelinquentLockMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [overrideDelinquentLockMutation, { data, loading, error }] = useOverrideDelinquentLockMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      override: // value for 'override'\n *   },\n * });\n */\nexport function useOverrideDelinquentLockMutation(baseOptions?: Apollo.MutationHookOptions<OverrideDelinquentLockMutation, OverrideDelinquentLockMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<OverrideDelinquentLockMutation, OverrideDelinquentLockMutationVariables>(OverrideDelinquentLockDocument, options);\n      }\nexport type OverrideDelinquentLockMutationHookResult = ReturnType<typeof useOverrideDelinquentLockMutation>;\nexport type OverrideDelinquentLockMutationResult = Apollo.MutationResult<OverrideDelinquentLockMutation>;\nexport type OverrideDelinquentLockMutationOptions = Apollo.BaseMutationOptions<OverrideDelinquentLockMutation, OverrideDelinquentLockMutationVariables>;\nexport const ResumeSubscriptionDocument: TypedDocumentNode<ResumeSubscriptionMutation, ResumeSubscriptionMutationVariables> = gql`\n  mutation resumeSubscription($organisation: OrganisationCakeType!) {\n  pauseSubscription(organisation: $organisation, pause: false)\n}\n    `;\nexport type ResumeSubscriptionMutationFn = Apollo.MutationFunction<ResumeSubscriptionMutation, ResumeSubscriptionMutationVariables>;\n\n/**\n * __useResumeSubscriptionMutation__\n *\n * To run a mutation, you first call `useResumeSubscriptionMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useResumeSubscriptionMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [resumeSubscriptionMutation, { data, loading, error }] = useResumeSubscriptionMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useResumeSubscriptionMutation(baseOptions?: Apollo.MutationHookOptions<ResumeSubscriptionMutation, ResumeSubscriptionMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ResumeSubscriptionMutation, ResumeSubscriptionMutationVariables>(ResumeSubscriptionDocument, options);\n      }\nexport type ResumeSubscriptionMutationHookResult = ReturnType<typeof useResumeSubscriptionMutation>;\nexport type ResumeSubscriptionMutationResult = Apollo.MutationResult<ResumeSubscriptionMutation>;\nexport type ResumeSubscriptionMutationOptions = Apollo.BaseMutationOptions<ResumeSubscriptionMutation, ResumeSubscriptionMutationVariables>;\nexport const SendChurnDiscountRequestDocument: TypedDocumentNode<SendChurnDiscountRequestMutation, SendChurnDiscountRequestMutationVariables> = gql`\n  mutation sendChurnDiscountRequest($organisationId: OrganisationCakeType!) {\n  sendChurnDiscountRequest(organisation: $organisationId)\n}\n    `;\nexport type SendChurnDiscountRequestMutationFn = Apollo.MutationFunction<SendChurnDiscountRequestMutation, SendChurnDiscountRequestMutationVariables>;\n\n/**\n * __useSendChurnDiscountRequestMutation__\n *\n * To run a mutation, you first call `useSendChurnDiscountRequestMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSendChurnDiscountRequestMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [sendChurnDiscountRequestMutation, { data, loading, error }] = useSendChurnDiscountRequestMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useSendChurnDiscountRequestMutation(baseOptions?: Apollo.MutationHookOptions<SendChurnDiscountRequestMutation, SendChurnDiscountRequestMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SendChurnDiscountRequestMutation, SendChurnDiscountRequestMutationVariables>(SendChurnDiscountRequestDocument, options);\n      }\nexport type SendChurnDiscountRequestMutationHookResult = ReturnType<typeof useSendChurnDiscountRequestMutation>;\nexport type SendChurnDiscountRequestMutationResult = Apollo.MutationResult<SendChurnDiscountRequestMutation>;\nexport type SendChurnDiscountRequestMutationOptions = Apollo.BaseMutationOptions<SendChurnDiscountRequestMutation, SendChurnDiscountRequestMutationVariables>;\nexport const GetPlanNamesEsopDocument: TypedDocumentNode<GetPlanNamesEsopQuery, GetPlanNamesEsopQueryVariables> = gql`\n  query getPlanNamesESOP($organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  esops(organisationId: $organisationId, page: $page, itemsPerPage: $itemsPerPage) {\n    id\n    name\n  }\n}\n    `;\n\n/**\n * __useGetPlanNamesEsopQuery__\n *\n * To run a query within a React component, call `useGetPlanNamesEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanNamesEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanNamesEsopQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetPlanNamesEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlanNamesEsopQuery, GetPlanNamesEsopQueryVariables> & ({ variables: GetPlanNamesEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanNamesEsopQuery, GetPlanNamesEsopQueryVariables>(GetPlanNamesEsopDocument, options);\n      }\nexport function useGetPlanNamesEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanNamesEsopQuery, GetPlanNamesEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanNamesEsopQuery, GetPlanNamesEsopQueryVariables>(GetPlanNamesEsopDocument, options);\n        }\nexport function useGetPlanNamesEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanNamesEsopQuery, GetPlanNamesEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanNamesEsopQuery, GetPlanNamesEsopQueryVariables>(GetPlanNamesEsopDocument, options);\n        }\nexport type GetPlanNamesEsopQueryHookResult = ReturnType<typeof useGetPlanNamesEsopQuery>;\nexport type GetPlanNamesEsopLazyQueryHookResult = ReturnType<typeof useGetPlanNamesEsopLazyQuery>;\nexport type GetPlanNamesEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlanNamesEsopSuspenseQuery>;\nexport type GetPlanNamesEsopQueryResult = Apollo.QueryResult<GetPlanNamesEsopQuery, GetPlanNamesEsopQueryVariables>;\nexport function refetchGetPlanNamesEsopQuery(variables: GetPlanNamesEsopQueryVariables) {\n      return { query: GetPlanNamesEsopDocument, variables: variables };\n    }\nexport const GetOrganisationBoardMembersDataDocument: TypedDocumentNode<GetOrganisationBoardMembersDataQuery, GetOrganisationBoardMembersDataQueryVariables> = gql`\n  query getOrganisationBoardMembersData($organisationId: UUID!, $page: Int!, $itemsPerPage: Int!) {\n  officeholders(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    id\n    name\n    email\n    avatar\n    roles {\n      role\n      name\n    }\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationBoardMembersDataQuery__\n *\n * To run a query within a React component, call `useGetOrganisationBoardMembersDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationBoardMembersDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationBoardMembersDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetOrganisationBoardMembersDataQuery(baseOptions: Apollo.QueryHookOptions<GetOrganisationBoardMembersDataQuery, GetOrganisationBoardMembersDataQueryVariables> & ({ variables: GetOrganisationBoardMembersDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationBoardMembersDataQuery, GetOrganisationBoardMembersDataQueryVariables>(GetOrganisationBoardMembersDataDocument, options);\n      }\nexport function useGetOrganisationBoardMembersDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationBoardMembersDataQuery, GetOrganisationBoardMembersDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationBoardMembersDataQuery, GetOrganisationBoardMembersDataQueryVariables>(GetOrganisationBoardMembersDataDocument, options);\n        }\nexport function useGetOrganisationBoardMembersDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationBoardMembersDataQuery, GetOrganisationBoardMembersDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationBoardMembersDataQuery, GetOrganisationBoardMembersDataQueryVariables>(GetOrganisationBoardMembersDataDocument, options);\n        }\nexport type GetOrganisationBoardMembersDataQueryHookResult = ReturnType<typeof useGetOrganisationBoardMembersDataQuery>;\nexport type GetOrganisationBoardMembersDataLazyQueryHookResult = ReturnType<typeof useGetOrganisationBoardMembersDataLazyQuery>;\nexport type GetOrganisationBoardMembersDataSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationBoardMembersDataSuspenseQuery>;\nexport type GetOrganisationBoardMembersDataQueryResult = Apollo.QueryResult<GetOrganisationBoardMembersDataQuery, GetOrganisationBoardMembersDataQueryVariables>;\nexport function refetchGetOrganisationBoardMembersDataQuery(variables: GetOrganisationBoardMembersDataQueryVariables) {\n      return { query: GetOrganisationBoardMembersDataDocument, variables: variables };\n    }\nexport const CreateBoardApprovalDocument: TypedDocumentNode<CreateBoardApprovalMutation, CreateBoardApprovalMutationVariables> = gql`\n  mutation createBoardApproval($organisation: OrganisationCakeType!, $signers: [OfficeholderCakeType!]!, $esopOffers: [EsopOfferCakeType!]!, $autoGrant: Boolean!) {\n  createBoardApproval(\n    organisation: $organisation\n    signers: $signers\n    esopOffers: $esopOffers\n    autoGrant: $autoGrant\n  ) {\n    id\n  }\n}\n    `;\nexport type CreateBoardApprovalMutationFn = Apollo.MutationFunction<CreateBoardApprovalMutation, CreateBoardApprovalMutationVariables>;\n\n/**\n * __useCreateBoardApprovalMutation__\n *\n * To run a mutation, you first call `useCreateBoardApprovalMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateBoardApprovalMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createBoardApprovalMutation, { data, loading, error }] = useCreateBoardApprovalMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      signers: // value for 'signers'\n *      esopOffers: // value for 'esopOffers'\n *      autoGrant: // value for 'autoGrant'\n *   },\n * });\n */\nexport function useCreateBoardApprovalMutation(baseOptions?: Apollo.MutationHookOptions<CreateBoardApprovalMutation, CreateBoardApprovalMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateBoardApprovalMutation, CreateBoardApprovalMutationVariables>(CreateBoardApprovalDocument, options);\n      }\nexport type CreateBoardApprovalMutationHookResult = ReturnType<typeof useCreateBoardApprovalMutation>;\nexport type CreateBoardApprovalMutationResult = Apollo.MutationResult<CreateBoardApprovalMutation>;\nexport type CreateBoardApprovalMutationOptions = Apollo.BaseMutationOptions<CreateBoardApprovalMutation, CreateBoardApprovalMutationVariables>;\nexport const DeleteBoardApprovalDocument: TypedDocumentNode<DeleteBoardApprovalMutation, DeleteBoardApprovalMutationVariables> = gql`\n  mutation deleteBoardApproval($boardApproval: BoardApprovalCakeType!) {\n  deleteBoardApproval(boardApproval: $boardApproval)\n}\n    `;\nexport type DeleteBoardApprovalMutationFn = Apollo.MutationFunction<DeleteBoardApprovalMutation, DeleteBoardApprovalMutationVariables>;\n\n/**\n * __useDeleteBoardApprovalMutation__\n *\n * To run a mutation, you first call `useDeleteBoardApprovalMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteBoardApprovalMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteBoardApprovalMutation, { data, loading, error }] = useDeleteBoardApprovalMutation({\n *   variables: {\n *      boardApproval: // value for 'boardApproval'\n *   },\n * });\n */\nexport function useDeleteBoardApprovalMutation(baseOptions?: Apollo.MutationHookOptions<DeleteBoardApprovalMutation, DeleteBoardApprovalMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteBoardApprovalMutation, DeleteBoardApprovalMutationVariables>(DeleteBoardApprovalDocument, options);\n      }\nexport type DeleteBoardApprovalMutationHookResult = ReturnType<typeof useDeleteBoardApprovalMutation>;\nexport type DeleteBoardApprovalMutationResult = Apollo.MutationResult<DeleteBoardApprovalMutation>;\nexport type DeleteBoardApprovalMutationOptions = Apollo.BaseMutationOptions<DeleteBoardApprovalMutation, DeleteBoardApprovalMutationVariables>;\nexport const SendBoardApprovalReminderDocument: TypedDocumentNode<SendBoardApprovalReminderMutation, SendBoardApprovalReminderMutationVariables> = gql`\n  mutation sendBoardApprovalReminder($boardApproval: BoardApprovalCakeType!, $signerEmail: CleanString) {\n  sendBoardApprovalReminder(\n    boardApproval: $boardApproval\n    signerEmail: $signerEmail\n  )\n}\n    `;\nexport type SendBoardApprovalReminderMutationFn = Apollo.MutationFunction<SendBoardApprovalReminderMutation, SendBoardApprovalReminderMutationVariables>;\n\n/**\n * __useSendBoardApprovalReminderMutation__\n *\n * To run a mutation, you first call `useSendBoardApprovalReminderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSendBoardApprovalReminderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [sendBoardApprovalReminderMutation, { data, loading, error }] = useSendBoardApprovalReminderMutation({\n *   variables: {\n *      boardApproval: // value for 'boardApproval'\n *      signerEmail: // value for 'signerEmail'\n *   },\n * });\n */\nexport function useSendBoardApprovalReminderMutation(baseOptions?: Apollo.MutationHookOptions<SendBoardApprovalReminderMutation, SendBoardApprovalReminderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SendBoardApprovalReminderMutation, SendBoardApprovalReminderMutationVariables>(SendBoardApprovalReminderDocument, options);\n      }\nexport type SendBoardApprovalReminderMutationHookResult = ReturnType<typeof useSendBoardApprovalReminderMutation>;\nexport type SendBoardApprovalReminderMutationResult = Apollo.MutationResult<SendBoardApprovalReminderMutation>;\nexport type SendBoardApprovalReminderMutationOptions = Apollo.BaseMutationOptions<SendBoardApprovalReminderMutation, SendBoardApprovalReminderMutationVariables>;\nexport const BoardApprovalsDocument: TypedDocumentNode<BoardApprovalsQuery, BoardApprovalsQueryVariables> = gql`\n  query boardApprovals($organisation: OrganisationCakeType!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!) {\n  boardApprovals(\n    organisation: $organisation\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    pageData {\n      id\n      created\n      createdBy {\n        firstName\n        lastName\n      }\n      planName\n      status\n      contract {\n        id\n        name\n        signatures {\n          name\n          email\n          status\n        }\n      }\n      signingLink\n      signerName\n      signerEmail\n      signatureId\n      esopOffers {\n        id\n        vestStartDate\n        shareholderDisplayName\n        vestingValue\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useBoardApprovalsQuery__\n *\n * To run a query within a React component, call `useBoardApprovalsQuery` and pass it any options that fit your needs.\n * When your component renders, `useBoardApprovalsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useBoardApprovalsQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useBoardApprovalsQuery(baseOptions: Apollo.QueryHookOptions<BoardApprovalsQuery, BoardApprovalsQueryVariables> & ({ variables: BoardApprovalsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<BoardApprovalsQuery, BoardApprovalsQueryVariables>(BoardApprovalsDocument, options);\n      }\nexport function useBoardApprovalsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BoardApprovalsQuery, BoardApprovalsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<BoardApprovalsQuery, BoardApprovalsQueryVariables>(BoardApprovalsDocument, options);\n        }\nexport function useBoardApprovalsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BoardApprovalsQuery, BoardApprovalsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<BoardApprovalsQuery, BoardApprovalsQueryVariables>(BoardApprovalsDocument, options);\n        }\nexport type BoardApprovalsQueryHookResult = ReturnType<typeof useBoardApprovalsQuery>;\nexport type BoardApprovalsLazyQueryHookResult = ReturnType<typeof useBoardApprovalsLazyQuery>;\nexport type BoardApprovalsSuspenseQueryHookResult = ReturnType<typeof useBoardApprovalsSuspenseQuery>;\nexport type BoardApprovalsQueryResult = Apollo.QueryResult<BoardApprovalsQuery, BoardApprovalsQueryVariables>;\nexport function refetchBoardApprovalsQuery(variables: BoardApprovalsQueryVariables) {\n      return { query: BoardApprovalsDocument, variables: variables };\n    }\nexport const BoardApprovalDetailsDocument: TypedDocumentNode<BoardApprovalDetailsQuery, BoardApprovalDetailsQueryVariables> = gql`\n  query boardApprovalDetails($boardApproval: BoardApprovalCakeType!, $organisationId: UUID!) {\n  boardApprovalDetails(boardApproval: $boardApproval) {\n    id\n    created\n    createdBy {\n      firstName\n      lastName\n    }\n    planName\n    status\n    autoGrant\n    contract {\n      id\n      name\n      signatures {\n        name\n        email\n        status\n      }\n    }\n    signingLink\n    signerName\n    signerEmail\n    signatureId\n    esopOffers {\n      id\n      vestStartDate\n      shareholderDisplayName\n      vestingValue\n    }\n  }\n  organisation(organisationId: $organisationId) {\n    fullyDilutedShares\n  }\n}\n    `;\n\n/**\n * __useBoardApprovalDetailsQuery__\n *\n * To run a query within a React component, call `useBoardApprovalDetailsQuery` and pass it any options that fit your needs.\n * When your component renders, `useBoardApprovalDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useBoardApprovalDetailsQuery({\n *   variables: {\n *      boardApproval: // value for 'boardApproval'\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useBoardApprovalDetailsQuery(baseOptions: Apollo.QueryHookOptions<BoardApprovalDetailsQuery, BoardApprovalDetailsQueryVariables> & ({ variables: BoardApprovalDetailsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<BoardApprovalDetailsQuery, BoardApprovalDetailsQueryVariables>(BoardApprovalDetailsDocument, options);\n      }\nexport function useBoardApprovalDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BoardApprovalDetailsQuery, BoardApprovalDetailsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<BoardApprovalDetailsQuery, BoardApprovalDetailsQueryVariables>(BoardApprovalDetailsDocument, options);\n        }\nexport function useBoardApprovalDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BoardApprovalDetailsQuery, BoardApprovalDetailsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<BoardApprovalDetailsQuery, BoardApprovalDetailsQueryVariables>(BoardApprovalDetailsDocument, options);\n        }\nexport type BoardApprovalDetailsQueryHookResult = ReturnType<typeof useBoardApprovalDetailsQuery>;\nexport type BoardApprovalDetailsLazyQueryHookResult = ReturnType<typeof useBoardApprovalDetailsLazyQuery>;\nexport type BoardApprovalDetailsSuspenseQueryHookResult = ReturnType<typeof useBoardApprovalDetailsSuspenseQuery>;\nexport type BoardApprovalDetailsQueryResult = Apollo.QueryResult<BoardApprovalDetailsQuery, BoardApprovalDetailsQueryVariables>;\nexport function refetchBoardApprovalDetailsQuery(variables: BoardApprovalDetailsQueryVariables) {\n      return { query: BoardApprovalDetailsDocument, variables: variables };\n    }\nexport const GetOrganisationAvailableBoardMembersRolesDocument: TypedDocumentNode<GetOrganisationAvailableBoardMembersRolesQuery, GetOrganisationAvailableBoardMembersRolesQueryVariables> = gql`\n  query getOrganisationAvailableBoardMembersRoles {\n  availableOfficeholderRoles {\n    role\n    name\n  }\n  availableOrganisationRoles {\n    roles {\n      role\n      description\n    }\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationAvailableBoardMembersRolesQuery__\n *\n * To run a query within a React component, call `useGetOrganisationAvailableBoardMembersRolesQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationAvailableBoardMembersRolesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationAvailableBoardMembersRolesQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useGetOrganisationAvailableBoardMembersRolesQuery(baseOptions?: Apollo.QueryHookOptions<GetOrganisationAvailableBoardMembersRolesQuery, GetOrganisationAvailableBoardMembersRolesQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationAvailableBoardMembersRolesQuery, GetOrganisationAvailableBoardMembersRolesQueryVariables>(GetOrganisationAvailableBoardMembersRolesDocument, options);\n      }\nexport function useGetOrganisationAvailableBoardMembersRolesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationAvailableBoardMembersRolesQuery, GetOrganisationAvailableBoardMembersRolesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationAvailableBoardMembersRolesQuery, GetOrganisationAvailableBoardMembersRolesQueryVariables>(GetOrganisationAvailableBoardMembersRolesDocument, options);\n        }\nexport function useGetOrganisationAvailableBoardMembersRolesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationAvailableBoardMembersRolesQuery, GetOrganisationAvailableBoardMembersRolesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationAvailableBoardMembersRolesQuery, GetOrganisationAvailableBoardMembersRolesQueryVariables>(GetOrganisationAvailableBoardMembersRolesDocument, options);\n        }\nexport type GetOrganisationAvailableBoardMembersRolesQueryHookResult = ReturnType<typeof useGetOrganisationAvailableBoardMembersRolesQuery>;\nexport type GetOrganisationAvailableBoardMembersRolesLazyQueryHookResult = ReturnType<typeof useGetOrganisationAvailableBoardMembersRolesLazyQuery>;\nexport type GetOrganisationAvailableBoardMembersRolesSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationAvailableBoardMembersRolesSuspenseQuery>;\nexport type GetOrganisationAvailableBoardMembersRolesQueryResult = Apollo.QueryResult<GetOrganisationAvailableBoardMembersRolesQuery, GetOrganisationAvailableBoardMembersRolesQueryVariables>;\nexport function refetchGetOrganisationAvailableBoardMembersRolesQuery(variables?: GetOrganisationAvailableBoardMembersRolesQueryVariables) {\n      return { query: GetOrganisationAvailableBoardMembersRolesDocument, variables: variables };\n    }\nexport const AddOBoardMemberDocument: TypedDocumentNode<AddOBoardMemberMutation, AddOBoardMemberMutationVariables> = gql`\n  mutation addOBoardMember($addOfficeholderData: AddOfficeholderData!) {\n  addOfficeholder(addOfficeholderData: $addOfficeholderData) {\n    officeholder {\n      id\n    }\n  }\n}\n    `;\nexport type AddOBoardMemberMutationFn = Apollo.MutationFunction<AddOBoardMemberMutation, AddOBoardMemberMutationVariables>;\n\n/**\n * __useAddOBoardMemberMutation__\n *\n * To run a mutation, you first call `useAddOBoardMemberMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddOBoardMemberMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addOBoardMemberMutation, { data, loading, error }] = useAddOBoardMemberMutation({\n *   variables: {\n *      addOfficeholderData: // value for 'addOfficeholderData'\n *   },\n * });\n */\nexport function useAddOBoardMemberMutation(baseOptions?: Apollo.MutationHookOptions<AddOBoardMemberMutation, AddOBoardMemberMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddOBoardMemberMutation, AddOBoardMemberMutationVariables>(AddOBoardMemberDocument, options);\n      }\nexport type AddOBoardMemberMutationHookResult = ReturnType<typeof useAddOBoardMemberMutation>;\nexport type AddOBoardMemberMutationResult = Apollo.MutationResult<AddOBoardMemberMutation>;\nexport type AddOBoardMemberMutationOptions = Apollo.BaseMutationOptions<AddOBoardMemberMutation, AddOBoardMemberMutationVariables>;\nexport const GetCommentsDocument: TypedDocumentNode<GetCommentsQuery, GetCommentsQueryVariables> = gql`\n  query GetComments($instanceId: UUID!, $modelType: CommentModelTypeEnum!) {\n  getComments(instanceId: $instanceId, modelType: $modelType) {\n    id\n    content\n    created\n    user {\n      id\n      firstName\n      lastName\n      picture\n    }\n  }\n}\n    `;\n\n/**\n * __useGetCommentsQuery__\n *\n * To run a query within a React component, call `useGetCommentsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetCommentsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetCommentsQuery({\n *   variables: {\n *      instanceId: // value for 'instanceId'\n *      modelType: // value for 'modelType'\n *   },\n * });\n */\nexport function useGetCommentsQuery(baseOptions: Apollo.QueryHookOptions<GetCommentsQuery, GetCommentsQueryVariables> & ({ variables: GetCommentsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetCommentsQuery, GetCommentsQueryVariables>(GetCommentsDocument, options);\n      }\nexport function useGetCommentsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCommentsQuery, GetCommentsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetCommentsQuery, GetCommentsQueryVariables>(GetCommentsDocument, options);\n        }\nexport function useGetCommentsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetCommentsQuery, GetCommentsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetCommentsQuery, GetCommentsQueryVariables>(GetCommentsDocument, options);\n        }\nexport type GetCommentsQueryHookResult = ReturnType<typeof useGetCommentsQuery>;\nexport type GetCommentsLazyQueryHookResult = ReturnType<typeof useGetCommentsLazyQuery>;\nexport type GetCommentsSuspenseQueryHookResult = ReturnType<typeof useGetCommentsSuspenseQuery>;\nexport type GetCommentsQueryResult = Apollo.QueryResult<GetCommentsQuery, GetCommentsQueryVariables>;\nexport function refetchGetCommentsQuery(variables: GetCommentsQueryVariables) {\n      return { query: GetCommentsDocument, variables: variables };\n    }\nexport const DeleteCommentDocument: TypedDocumentNode<DeleteCommentMutation, DeleteCommentMutationVariables> = gql`\n  mutation DeleteComment($commentIds: [UUID!]!) {\n  deleteComment(commentIds: $commentIds)\n}\n    `;\nexport type DeleteCommentMutationFn = Apollo.MutationFunction<DeleteCommentMutation, DeleteCommentMutationVariables>;\n\n/**\n * __useDeleteCommentMutation__\n *\n * To run a mutation, you first call `useDeleteCommentMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteCommentMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteCommentMutation, { data, loading, error }] = useDeleteCommentMutation({\n *   variables: {\n *      commentIds: // value for 'commentIds'\n *   },\n * });\n */\nexport function useDeleteCommentMutation(baseOptions?: Apollo.MutationHookOptions<DeleteCommentMutation, DeleteCommentMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteCommentMutation, DeleteCommentMutationVariables>(DeleteCommentDocument, options);\n      }\nexport type DeleteCommentMutationHookResult = ReturnType<typeof useDeleteCommentMutation>;\nexport type DeleteCommentMutationResult = Apollo.MutationResult<DeleteCommentMutation>;\nexport type DeleteCommentMutationOptions = Apollo.BaseMutationOptions<DeleteCommentMutation, DeleteCommentMutationVariables>;\nexport const CreateCommentDocument: TypedDocumentNode<CreateCommentMutation, CreateCommentMutationVariables> = gql`\n  mutation CreateComment($content: String!, $instanceId: UUID!, $modelType: CommentModelTypeEnum!) {\n  createComment(content: $content, instanceId: $instanceId, modelType: $modelType)\n}\n    `;\nexport type CreateCommentMutationFn = Apollo.MutationFunction<CreateCommentMutation, CreateCommentMutationVariables>;\n\n/**\n * __useCreateCommentMutation__\n *\n * To run a mutation, you first call `useCreateCommentMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateCommentMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createCommentMutation, { data, loading, error }] = useCreateCommentMutation({\n *   variables: {\n *      content: // value for 'content'\n *      instanceId: // value for 'instanceId'\n *      modelType: // value for 'modelType'\n *   },\n * });\n */\nexport function useCreateCommentMutation(baseOptions?: Apollo.MutationHookOptions<CreateCommentMutation, CreateCommentMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateCommentMutation, CreateCommentMutationVariables>(CreateCommentDocument, options);\n      }\nexport type CreateCommentMutationHookResult = ReturnType<typeof useCreateCommentMutation>;\nexport type CreateCommentMutationResult = Apollo.MutationResult<CreateCommentMutation>;\nexport type CreateCommentMutationOptions = Apollo.BaseMutationOptions<CreateCommentMutation, CreateCommentMutationVariables>;\nexport const SbcOffersDocument: TypedDocumentNode<SbcOffersQuery, SbcOffersQueryVariables> = gql`\n  query sbcOffers($organisationId: UUID!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $fromDate: Date, $toDate: Date) {\n  sbcOffers(\n    organisationId: $organisationId\n    fromDate: $fromDate\n    toDate: $toDate\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    currentPage\n    count\n    pageData {\n      __typename\n      ... on EsopOffer {\n        optionType\n        id\n        dateGranted\n        lastEventDate\n        vestStartDate\n        totalDays\n        totalCliffDays\n        totalPeriodicDays\n        totalGranted\n        calendar {\n          entries {\n            date\n            accumulated\n            lapsed\n            entryType\n          }\n        }\n        shareholder {\n          id\n          displayName\n          avatar\n        }\n      }\n      ... on EssOffer {\n        id\n        dateGranted\n        lastEventDate\n        vestStartDate\n        totalDays\n        totalCliffDays\n        totalPeriodicDays\n        totalGranted\n        calendar {\n          entries {\n            date\n            accumulated\n            lapsed\n            entryType\n          }\n        }\n        shareholder {\n          id\n          displayName\n          avatar\n        }\n      }\n      ... on RsuOfferOutputType {\n        id\n        dateGranted\n        lastEventDate\n        vestStartDate\n        totalDays\n        totalCliffDays\n        totalPeriodicDays\n        totalGranted\n        calendar {\n          entries {\n            date\n            accumulated\n            lapsed\n            entryType\n          }\n        }\n        shareholder {\n          id\n          displayName\n          avatar\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useSbcOffersQuery__\n *\n * To run a query within a React component, call `useSbcOffersQuery` and pass it any options that fit your needs.\n * When your component renders, `useSbcOffersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useSbcOffersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      fromDate: // value for 'fromDate'\n *      toDate: // value for 'toDate'\n *   },\n * });\n */\nexport function useSbcOffersQuery(baseOptions: Apollo.QueryHookOptions<SbcOffersQuery, SbcOffersQueryVariables> & ({ variables: SbcOffersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<SbcOffersQuery, SbcOffersQueryVariables>(SbcOffersDocument, options);\n      }\nexport function useSbcOffersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SbcOffersQuery, SbcOffersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<SbcOffersQuery, SbcOffersQueryVariables>(SbcOffersDocument, options);\n        }\nexport function useSbcOffersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<SbcOffersQuery, SbcOffersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<SbcOffersQuery, SbcOffersQueryVariables>(SbcOffersDocument, options);\n        }\nexport type SbcOffersQueryHookResult = ReturnType<typeof useSbcOffersQuery>;\nexport type SbcOffersLazyQueryHookResult = ReturnType<typeof useSbcOffersLazyQuery>;\nexport type SbcOffersSuspenseQueryHookResult = ReturnType<typeof useSbcOffersSuspenseQuery>;\nexport type SbcOffersQueryResult = Apollo.QueryResult<SbcOffersQuery, SbcOffersQueryVariables>;\nexport function refetchSbcOffersQuery(variables: SbcOffersQueryVariables) {\n      return { query: SbcOffersDocument, variables: variables };\n    }\nexport const SendAsc718RequestDocument: TypedDocumentNode<SendAsc718RequestMutation, SendAsc718RequestMutationVariables> = gql`\n  mutation SendAsc718Request($organisationId: OrganisationCakeType!) {\n  sendAsc718Request(organisation: $organisationId)\n}\n    `;\nexport type SendAsc718RequestMutationFn = Apollo.MutationFunction<SendAsc718RequestMutation, SendAsc718RequestMutationVariables>;\n\n/**\n * __useSendAsc718RequestMutation__\n *\n * To run a mutation, you first call `useSendAsc718RequestMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSendAsc718RequestMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [sendAsc718RequestMutation, { data, loading, error }] = useSendAsc718RequestMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useSendAsc718RequestMutation(baseOptions?: Apollo.MutationHookOptions<SendAsc718RequestMutation, SendAsc718RequestMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SendAsc718RequestMutation, SendAsc718RequestMutationVariables>(SendAsc718RequestDocument, options);\n      }\nexport type SendAsc718RequestMutationHookResult = ReturnType<typeof useSendAsc718RequestMutation>;\nexport type SendAsc718RequestMutationResult = Apollo.MutationResult<SendAsc718RequestMutation>;\nexport type SendAsc718RequestMutationOptions = Apollo.BaseMutationOptions<SendAsc718RequestMutation, SendAsc718RequestMutationVariables>;\nexport const QsbsTransactionsDocument: TypedDocumentNode<QsbsTransactionsQuery, QsbsTransactionsQueryVariables> = gql`\n  query QsbsTransactions($organisation: OrganisationCakeType!, $cutoffDate: Date, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!) {\n  qsbsTransactions(\n    organisation: $organisation\n    cutoffDate: $cutoffDate\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    currentPage\n    count\n    pageData {\n      shareholderId\n      displayName\n      transactionId\n      sharetypeName\n      transactionDate\n      qsbsSharesWith83b\n      qsbsSharesWithout83b\n      hasVestingEvent\n    }\n  }\n}\n    `;\n\n/**\n * __useQsbsTransactionsQuery__\n *\n * To run a query within a React component, call `useQsbsTransactionsQuery` and pass it any options that fit your needs.\n * When your component renders, `useQsbsTransactionsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useQsbsTransactionsQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      cutoffDate: // value for 'cutoffDate'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useQsbsTransactionsQuery(baseOptions: Apollo.QueryHookOptions<QsbsTransactionsQuery, QsbsTransactionsQueryVariables> & ({ variables: QsbsTransactionsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<QsbsTransactionsQuery, QsbsTransactionsQueryVariables>(QsbsTransactionsDocument, options);\n      }\nexport function useQsbsTransactionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<QsbsTransactionsQuery, QsbsTransactionsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<QsbsTransactionsQuery, QsbsTransactionsQueryVariables>(QsbsTransactionsDocument, options);\n        }\nexport function useQsbsTransactionsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<QsbsTransactionsQuery, QsbsTransactionsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<QsbsTransactionsQuery, QsbsTransactionsQueryVariables>(QsbsTransactionsDocument, options);\n        }\nexport type QsbsTransactionsQueryHookResult = ReturnType<typeof useQsbsTransactionsQuery>;\nexport type QsbsTransactionsLazyQueryHookResult = ReturnType<typeof useQsbsTransactionsLazyQuery>;\nexport type QsbsTransactionsSuspenseQueryHookResult = ReturnType<typeof useQsbsTransactionsSuspenseQuery>;\nexport type QsbsTransactionsQueryResult = Apollo.QueryResult<QsbsTransactionsQuery, QsbsTransactionsQueryVariables>;\nexport function refetchQsbsTransactionsQuery(variables: QsbsTransactionsQueryVariables) {\n      return { query: QsbsTransactionsDocument, variables: variables };\n    }\nexport const GenerateQsbsReportForTransactionsDocument: TypedDocumentNode<GenerateQsbsReportForTransactionsMutation, GenerateQsbsReportForTransactionsMutationVariables> = gql`\n  mutation GenerateQsbsReportForTransactions($organisation: OrganisationCakeType!, $transactionIds: [UUID!]!, $qsbsForm: QsbsFormInputType!) {\n  generateQsbsReportForTransactions(\n    organisation: $organisation\n    transactionIds: $transactionIds\n    qsbsForm: $qsbsForm\n  )\n}\n    `;\nexport type GenerateQsbsReportForTransactionsMutationFn = Apollo.MutationFunction<GenerateQsbsReportForTransactionsMutation, GenerateQsbsReportForTransactionsMutationVariables>;\n\n/**\n * __useGenerateQsbsReportForTransactionsMutation__\n *\n * To run a mutation, you first call `useGenerateQsbsReportForTransactionsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useGenerateQsbsReportForTransactionsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [generateQsbsReportForTransactionsMutation, { data, loading, error }] = useGenerateQsbsReportForTransactionsMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      transactionIds: // value for 'transactionIds'\n *      qsbsForm: // value for 'qsbsForm'\n *   },\n * });\n */\nexport function useGenerateQsbsReportForTransactionsMutation(baseOptions?: Apollo.MutationHookOptions<GenerateQsbsReportForTransactionsMutation, GenerateQsbsReportForTransactionsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<GenerateQsbsReportForTransactionsMutation, GenerateQsbsReportForTransactionsMutationVariables>(GenerateQsbsReportForTransactionsDocument, options);\n      }\nexport type GenerateQsbsReportForTransactionsMutationHookResult = ReturnType<typeof useGenerateQsbsReportForTransactionsMutation>;\nexport type GenerateQsbsReportForTransactionsMutationResult = Apollo.MutationResult<GenerateQsbsReportForTransactionsMutation>;\nexport type GenerateQsbsReportForTransactionsMutationOptions = Apollo.BaseMutationOptions<GenerateQsbsReportForTransactionsMutation, GenerateQsbsReportForTransactionsMutationVariables>;\nexport const GetDashboardNumberOfStakeholdersDocument: TypedDocumentNode<GetDashboardNumberOfStakeholdersQuery, GetDashboardNumberOfStakeholdersQueryVariables> = gql`\n  query getDashboardNumberOfStakeholders($organisationId: OrganisationCakeType!) {\n  dashboardSecurities(organisation: $organisationId) {\n    numStakeholders\n  }\n}\n    `;\n\n/**\n * __useGetDashboardNumberOfStakeholdersQuery__\n *\n * To run a query within a React component, call `useGetDashboardNumberOfStakeholdersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDashboardNumberOfStakeholdersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDashboardNumberOfStakeholdersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetDashboardNumberOfStakeholdersQuery(baseOptions: Apollo.QueryHookOptions<GetDashboardNumberOfStakeholdersQuery, GetDashboardNumberOfStakeholdersQueryVariables> & ({ variables: GetDashboardNumberOfStakeholdersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDashboardNumberOfStakeholdersQuery, GetDashboardNumberOfStakeholdersQueryVariables>(GetDashboardNumberOfStakeholdersDocument, options);\n      }\nexport function useGetDashboardNumberOfStakeholdersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDashboardNumberOfStakeholdersQuery, GetDashboardNumberOfStakeholdersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDashboardNumberOfStakeholdersQuery, GetDashboardNumberOfStakeholdersQueryVariables>(GetDashboardNumberOfStakeholdersDocument, options);\n        }\nexport function useGetDashboardNumberOfStakeholdersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDashboardNumberOfStakeholdersQuery, GetDashboardNumberOfStakeholdersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDashboardNumberOfStakeholdersQuery, GetDashboardNumberOfStakeholdersQueryVariables>(GetDashboardNumberOfStakeholdersDocument, options);\n        }\nexport type GetDashboardNumberOfStakeholdersQueryHookResult = ReturnType<typeof useGetDashboardNumberOfStakeholdersQuery>;\nexport type GetDashboardNumberOfStakeholdersLazyQueryHookResult = ReturnType<typeof useGetDashboardNumberOfStakeholdersLazyQuery>;\nexport type GetDashboardNumberOfStakeholdersSuspenseQueryHookResult = ReturnType<typeof useGetDashboardNumberOfStakeholdersSuspenseQuery>;\nexport type GetDashboardNumberOfStakeholdersQueryResult = Apollo.QueryResult<GetDashboardNumberOfStakeholdersQuery, GetDashboardNumberOfStakeholdersQueryVariables>;\nexport function refetchGetDashboardNumberOfStakeholdersQuery(variables: GetDashboardNumberOfStakeholdersQueryVariables) {\n      return { query: GetDashboardNumberOfStakeholdersDocument, variables: variables };\n    }\nexport const GetDashboardOverviewDataDocument: TypedDocumentNode<GetDashboardOverviewDataQuery, GetDashboardOverviewDataQueryVariables> = gql`\n  query getDashboardOverviewData($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    logoImage: logoImageLink\n  }\n}\n    `;\n\n/**\n * __useGetDashboardOverviewDataQuery__\n *\n * To run a query within a React component, call `useGetDashboardOverviewDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDashboardOverviewDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDashboardOverviewDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetDashboardOverviewDataQuery(baseOptions: Apollo.QueryHookOptions<GetDashboardOverviewDataQuery, GetDashboardOverviewDataQueryVariables> & ({ variables: GetDashboardOverviewDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDashboardOverviewDataQuery, GetDashboardOverviewDataQueryVariables>(GetDashboardOverviewDataDocument, options);\n      }\nexport function useGetDashboardOverviewDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDashboardOverviewDataQuery, GetDashboardOverviewDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDashboardOverviewDataQuery, GetDashboardOverviewDataQueryVariables>(GetDashboardOverviewDataDocument, options);\n        }\nexport function useGetDashboardOverviewDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDashboardOverviewDataQuery, GetDashboardOverviewDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDashboardOverviewDataQuery, GetDashboardOverviewDataQueryVariables>(GetDashboardOverviewDataDocument, options);\n        }\nexport type GetDashboardOverviewDataQueryHookResult = ReturnType<typeof useGetDashboardOverviewDataQuery>;\nexport type GetDashboardOverviewDataLazyQueryHookResult = ReturnType<typeof useGetDashboardOverviewDataLazyQuery>;\nexport type GetDashboardOverviewDataSuspenseQueryHookResult = ReturnType<typeof useGetDashboardOverviewDataSuspenseQuery>;\nexport type GetDashboardOverviewDataQueryResult = Apollo.QueryResult<GetDashboardOverviewDataQuery, GetDashboardOverviewDataQueryVariables>;\nexport function refetchGetDashboardOverviewDataQuery(variables: GetDashboardOverviewDataQueryVariables) {\n      return { query: GetDashboardOverviewDataDocument, variables: variables };\n    }\nexport const GetDashboardActionsDataNewDocument: TypedDocumentNode<GetDashboardActionsDataNewQuery, GetDashboardActionsDataNewQueryVariables> = gql`\n  query getDashboardActionsDataNew($organisationId: OrganisationCakeType!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger) {\n  actionItems(\n    organisation: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    recent\n    pageData {\n      recent\n      description\n      link\n      snooze\n      itemDate\n      actionableId\n      actionType\n    }\n  }\n}\n    `;\n\n/**\n * __useGetDashboardActionsDataNewQuery__\n *\n * To run a query within a React component, call `useGetDashboardActionsDataNewQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDashboardActionsDataNewQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDashboardActionsDataNewQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetDashboardActionsDataNewQuery(baseOptions: Apollo.QueryHookOptions<GetDashboardActionsDataNewQuery, GetDashboardActionsDataNewQueryVariables> & ({ variables: GetDashboardActionsDataNewQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDashboardActionsDataNewQuery, GetDashboardActionsDataNewQueryVariables>(GetDashboardActionsDataNewDocument, options);\n      }\nexport function useGetDashboardActionsDataNewLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDashboardActionsDataNewQuery, GetDashboardActionsDataNewQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDashboardActionsDataNewQuery, GetDashboardActionsDataNewQueryVariables>(GetDashboardActionsDataNewDocument, options);\n        }\nexport function useGetDashboardActionsDataNewSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDashboardActionsDataNewQuery, GetDashboardActionsDataNewQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDashboardActionsDataNewQuery, GetDashboardActionsDataNewQueryVariables>(GetDashboardActionsDataNewDocument, options);\n        }\nexport type GetDashboardActionsDataNewQueryHookResult = ReturnType<typeof useGetDashboardActionsDataNewQuery>;\nexport type GetDashboardActionsDataNewLazyQueryHookResult = ReturnType<typeof useGetDashboardActionsDataNewLazyQuery>;\nexport type GetDashboardActionsDataNewSuspenseQueryHookResult = ReturnType<typeof useGetDashboardActionsDataNewSuspenseQuery>;\nexport type GetDashboardActionsDataNewQueryResult = Apollo.QueryResult<GetDashboardActionsDataNewQuery, GetDashboardActionsDataNewQueryVariables>;\nexport function refetchGetDashboardActionsDataNewQuery(variables: GetDashboardActionsDataNewQueryVariables) {\n      return { query: GetDashboardActionsDataNewDocument, variables: variables };\n    }\nexport const GetDashboardStatisticsDocument: TypedDocumentNode<GetDashboardStatisticsQuery, GetDashboardStatisticsQueryVariables> = gql`\n  query getDashboardStatistics($organisationId: OrganisationCakeType!) {\n  dashboardStatistics(organisation: $organisationId) {\n    numStakeholders\n    totalShares\n    totalSecurities\n    valuation\n    sharetypes\n  }\n}\n    `;\n\n/**\n * __useGetDashboardStatisticsQuery__\n *\n * To run a query within a React component, call `useGetDashboardStatisticsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDashboardStatisticsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDashboardStatisticsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetDashboardStatisticsQuery(baseOptions: Apollo.QueryHookOptions<GetDashboardStatisticsQuery, GetDashboardStatisticsQueryVariables> & ({ variables: GetDashboardStatisticsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDashboardStatisticsQuery, GetDashboardStatisticsQueryVariables>(GetDashboardStatisticsDocument, options);\n      }\nexport function useGetDashboardStatisticsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDashboardStatisticsQuery, GetDashboardStatisticsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDashboardStatisticsQuery, GetDashboardStatisticsQueryVariables>(GetDashboardStatisticsDocument, options);\n        }\nexport function useGetDashboardStatisticsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDashboardStatisticsQuery, GetDashboardStatisticsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDashboardStatisticsQuery, GetDashboardStatisticsQueryVariables>(GetDashboardStatisticsDocument, options);\n        }\nexport type GetDashboardStatisticsQueryHookResult = ReturnType<typeof useGetDashboardStatisticsQuery>;\nexport type GetDashboardStatisticsLazyQueryHookResult = ReturnType<typeof useGetDashboardStatisticsLazyQuery>;\nexport type GetDashboardStatisticsSuspenseQueryHookResult = ReturnType<typeof useGetDashboardStatisticsSuspenseQuery>;\nexport type GetDashboardStatisticsQueryResult = Apollo.QueryResult<GetDashboardStatisticsQuery, GetDashboardStatisticsQueryVariables>;\nexport function refetchGetDashboardStatisticsQuery(variables: GetDashboardStatisticsQueryVariables) {\n      return { query: GetDashboardStatisticsDocument, variables: variables };\n    }\nexport const DashboardTopStakeholdersDocument: TypedDocumentNode<DashboardTopStakeholdersQuery, DashboardTopStakeholdersQueryVariables> = gql`\n  query dashboardTopStakeholders($organisationId: OrganisationCakeType!, $n: PositiveInteger, $excludeOthersFromCount: Boolean) {\n  dashboardTopStakeholders(\n    organisation: $organisationId\n    n: $n\n    excludeOthersFromCount: $excludeOthersFromCount\n  ) {\n    dilluted {\n      name\n      ownership\n      securities\n      synthetic\n    }\n    undilluted {\n      name\n      ownership\n      securities\n      synthetic\n    }\n  }\n}\n    `;\n\n/**\n * __useDashboardTopStakeholdersQuery__\n *\n * To run a query within a React component, call `useDashboardTopStakeholdersQuery` and pass it any options that fit your needs.\n * When your component renders, `useDashboardTopStakeholdersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDashboardTopStakeholdersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      n: // value for 'n'\n *      excludeOthersFromCount: // value for 'excludeOthersFromCount'\n *   },\n * });\n */\nexport function useDashboardTopStakeholdersQuery(baseOptions: Apollo.QueryHookOptions<DashboardTopStakeholdersQuery, DashboardTopStakeholdersQueryVariables> & ({ variables: DashboardTopStakeholdersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DashboardTopStakeholdersQuery, DashboardTopStakeholdersQueryVariables>(DashboardTopStakeholdersDocument, options);\n      }\nexport function useDashboardTopStakeholdersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DashboardTopStakeholdersQuery, DashboardTopStakeholdersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DashboardTopStakeholdersQuery, DashboardTopStakeholdersQueryVariables>(DashboardTopStakeholdersDocument, options);\n        }\nexport function useDashboardTopStakeholdersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DashboardTopStakeholdersQuery, DashboardTopStakeholdersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DashboardTopStakeholdersQuery, DashboardTopStakeholdersQueryVariables>(DashboardTopStakeholdersDocument, options);\n        }\nexport type DashboardTopStakeholdersQueryHookResult = ReturnType<typeof useDashboardTopStakeholdersQuery>;\nexport type DashboardTopStakeholdersLazyQueryHookResult = ReturnType<typeof useDashboardTopStakeholdersLazyQuery>;\nexport type DashboardTopStakeholdersSuspenseQueryHookResult = ReturnType<typeof useDashboardTopStakeholdersSuspenseQuery>;\nexport type DashboardTopStakeholdersQueryResult = Apollo.QueryResult<DashboardTopStakeholdersQuery, DashboardTopStakeholdersQueryVariables>;\nexport function refetchDashboardTopStakeholdersQuery(variables: DashboardTopStakeholdersQueryVariables) {\n      return { query: DashboardTopStakeholdersDocument, variables: variables };\n    }\nexport const GetDashboardSecuritiesDocument: TypedDocumentNode<GetDashboardSecuritiesQuery, GetDashboardSecuritiesQueryVariables> = gql`\n  query getDashboardSecurities($organisationId: OrganisationCakeType!) {\n  dashboardSecurities(organisation: $organisationId) {\n    totalShares\n    numShareholders\n    totalOptions\n    numOptionholders\n    totalRsus\n    numRsuholders\n  }\n}\n    `;\n\n/**\n * __useGetDashboardSecuritiesQuery__\n *\n * To run a query within a React component, call `useGetDashboardSecuritiesQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDashboardSecuritiesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDashboardSecuritiesQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetDashboardSecuritiesQuery(baseOptions: Apollo.QueryHookOptions<GetDashboardSecuritiesQuery, GetDashboardSecuritiesQueryVariables> & ({ variables: GetDashboardSecuritiesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDashboardSecuritiesQuery, GetDashboardSecuritiesQueryVariables>(GetDashboardSecuritiesDocument, options);\n      }\nexport function useGetDashboardSecuritiesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDashboardSecuritiesQuery, GetDashboardSecuritiesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDashboardSecuritiesQuery, GetDashboardSecuritiesQueryVariables>(GetDashboardSecuritiesDocument, options);\n        }\nexport function useGetDashboardSecuritiesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDashboardSecuritiesQuery, GetDashboardSecuritiesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDashboardSecuritiesQuery, GetDashboardSecuritiesQueryVariables>(GetDashboardSecuritiesDocument, options);\n        }\nexport type GetDashboardSecuritiesQueryHookResult = ReturnType<typeof useGetDashboardSecuritiesQuery>;\nexport type GetDashboardSecuritiesLazyQueryHookResult = ReturnType<typeof useGetDashboardSecuritiesLazyQuery>;\nexport type GetDashboardSecuritiesSuspenseQueryHookResult = ReturnType<typeof useGetDashboardSecuritiesSuspenseQuery>;\nexport type GetDashboardSecuritiesQueryResult = Apollo.QueryResult<GetDashboardSecuritiesQuery, GetDashboardSecuritiesQueryVariables>;\nexport function refetchGetDashboardSecuritiesQuery(variables: GetDashboardSecuritiesQueryVariables) {\n      return { query: GetDashboardSecuritiesDocument, variables: variables };\n    }\nexport const GetDashboardKudosDocument: TypedDocumentNode<GetDashboardKudosQuery, GetDashboardKudosQueryVariables> = gql`\n  query getDashboardKudos($organisationId: OrganisationCakeType!, $page: Int, $itemsPerPage: Int) {\n  sentKudos(\n    organisation: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    pageData {\n      id\n      displayName\n      context\n      actionType\n      badge\n      message\n    }\n  }\n}\n    `;\n\n/**\n * __useGetDashboardKudosQuery__\n *\n * To run a query within a React component, call `useGetDashboardKudosQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDashboardKudosQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDashboardKudosQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetDashboardKudosQuery(baseOptions: Apollo.QueryHookOptions<GetDashboardKudosQuery, GetDashboardKudosQueryVariables> & ({ variables: GetDashboardKudosQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDashboardKudosQuery, GetDashboardKudosQueryVariables>(GetDashboardKudosDocument, options);\n      }\nexport function useGetDashboardKudosLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDashboardKudosQuery, GetDashboardKudosQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDashboardKudosQuery, GetDashboardKudosQueryVariables>(GetDashboardKudosDocument, options);\n        }\nexport function useGetDashboardKudosSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDashboardKudosQuery, GetDashboardKudosQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDashboardKudosQuery, GetDashboardKudosQueryVariables>(GetDashboardKudosDocument, options);\n        }\nexport type GetDashboardKudosQueryHookResult = ReturnType<typeof useGetDashboardKudosQuery>;\nexport type GetDashboardKudosLazyQueryHookResult = ReturnType<typeof useGetDashboardKudosLazyQuery>;\nexport type GetDashboardKudosSuspenseQueryHookResult = ReturnType<typeof useGetDashboardKudosSuspenseQuery>;\nexport type GetDashboardKudosQueryResult = Apollo.QueryResult<GetDashboardKudosQuery, GetDashboardKudosQueryVariables>;\nexport function refetchGetDashboardKudosQuery(variables: GetDashboardKudosQueryVariables) {\n      return { query: GetDashboardKudosDocument, variables: variables };\n    }\nexport const DashboardShareholdersPerQuarterDocument: TypedDocumentNode<DashboardShareholdersPerQuarterQuery, DashboardShareholdersPerQuarterQueryVariables> = gql`\n  query dashboardShareholdersPerQuarter($organisationId: OrganisationCakeType!, $numberOfQuarters: Int) {\n  dashboardShareholdersPerQuarter(\n    organisation: $organisationId\n    numberOfQuarters: $numberOfQuarters\n  ) {\n    year\n    quarter\n    totalStakeholders\n    totalSecurities\n    newStakeholdersCount\n    newStakeholders {\n      id\n      displayName\n      avatar\n    }\n  }\n}\n    `;\n\n/**\n * __useDashboardShareholdersPerQuarterQuery__\n *\n * To run a query within a React component, call `useDashboardShareholdersPerQuarterQuery` and pass it any options that fit your needs.\n * When your component renders, `useDashboardShareholdersPerQuarterQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDashboardShareholdersPerQuarterQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      numberOfQuarters: // value for 'numberOfQuarters'\n *   },\n * });\n */\nexport function useDashboardShareholdersPerQuarterQuery(baseOptions: Apollo.QueryHookOptions<DashboardShareholdersPerQuarterQuery, DashboardShareholdersPerQuarterQueryVariables> & ({ variables: DashboardShareholdersPerQuarterQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DashboardShareholdersPerQuarterQuery, DashboardShareholdersPerQuarterQueryVariables>(DashboardShareholdersPerQuarterDocument, options);\n      }\nexport function useDashboardShareholdersPerQuarterLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DashboardShareholdersPerQuarterQuery, DashboardShareholdersPerQuarterQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DashboardShareholdersPerQuarterQuery, DashboardShareholdersPerQuarterQueryVariables>(DashboardShareholdersPerQuarterDocument, options);\n        }\nexport function useDashboardShareholdersPerQuarterSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DashboardShareholdersPerQuarterQuery, DashboardShareholdersPerQuarterQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DashboardShareholdersPerQuarterQuery, DashboardShareholdersPerQuarterQueryVariables>(DashboardShareholdersPerQuarterDocument, options);\n        }\nexport type DashboardShareholdersPerQuarterQueryHookResult = ReturnType<typeof useDashboardShareholdersPerQuarterQuery>;\nexport type DashboardShareholdersPerQuarterLazyQueryHookResult = ReturnType<typeof useDashboardShareholdersPerQuarterLazyQuery>;\nexport type DashboardShareholdersPerQuarterSuspenseQueryHookResult = ReturnType<typeof useDashboardShareholdersPerQuarterSuspenseQuery>;\nexport type DashboardShareholdersPerQuarterQueryResult = Apollo.QueryResult<DashboardShareholdersPerQuarterQuery, DashboardShareholdersPerQuarterQueryVariables>;\nexport function refetchDashboardShareholdersPerQuarterQuery(variables: DashboardShareholdersPerQuarterQueryVariables) {\n      return { query: DashboardShareholdersPerQuarterDocument, variables: variables };\n    }\nexport const DashboardNextVestingEventsDocument: TypedDocumentNode<DashboardNextVestingEventsQuery, DashboardNextVestingEventsQueryVariables> = gql`\n  query dashboardNextVestingEvents($organisationId: OrganisationCakeType!, $page: Int, $itemsPerPage: Int) {\n  dashboardNextVestingEvents(\n    organisation: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    pageData {\n      offerId\n      displayName\n      nextVestingDate\n      nextVestingMeta\n    }\n    imminentEventsCount\n  }\n}\n    `;\n\n/**\n * __useDashboardNextVestingEventsQuery__\n *\n * To run a query within a React component, call `useDashboardNextVestingEventsQuery` and pass it any options that fit your needs.\n * When your component renders, `useDashboardNextVestingEventsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDashboardNextVestingEventsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useDashboardNextVestingEventsQuery(baseOptions: Apollo.QueryHookOptions<DashboardNextVestingEventsQuery, DashboardNextVestingEventsQueryVariables> & ({ variables: DashboardNextVestingEventsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DashboardNextVestingEventsQuery, DashboardNextVestingEventsQueryVariables>(DashboardNextVestingEventsDocument, options);\n      }\nexport function useDashboardNextVestingEventsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DashboardNextVestingEventsQuery, DashboardNextVestingEventsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DashboardNextVestingEventsQuery, DashboardNextVestingEventsQueryVariables>(DashboardNextVestingEventsDocument, options);\n        }\nexport function useDashboardNextVestingEventsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DashboardNextVestingEventsQuery, DashboardNextVestingEventsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DashboardNextVestingEventsQuery, DashboardNextVestingEventsQueryVariables>(DashboardNextVestingEventsDocument, options);\n        }\nexport type DashboardNextVestingEventsQueryHookResult = ReturnType<typeof useDashboardNextVestingEventsQuery>;\nexport type DashboardNextVestingEventsLazyQueryHookResult = ReturnType<typeof useDashboardNextVestingEventsLazyQuery>;\nexport type DashboardNextVestingEventsSuspenseQueryHookResult = ReturnType<typeof useDashboardNextVestingEventsSuspenseQuery>;\nexport type DashboardNextVestingEventsQueryResult = Apollo.QueryResult<DashboardNextVestingEventsQuery, DashboardNextVestingEventsQueryVariables>;\nexport function refetchDashboardNextVestingEventsQuery(variables: DashboardNextVestingEventsQueryVariables) {\n      return { query: DashboardNextVestingEventsDocument, variables: variables };\n    }\nexport const DashboardIncentivePlansDocument: TypedDocumentNode<DashboardIncentivePlansQuery, DashboardIncentivePlansQueryVariables> = gql`\n  query dashboardIncentivePlans($organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  esops(organisationId: $organisationId, page: $page, itemsPerPage: $itemsPerPage) {\n    name\n    vestingValue\n    totalVested\n    totalLapsed\n    totalOffered\n  }\n  rsus(organisationId: $organisationId, page: $page, itemsPerPage: $itemsPerPage) {\n    name\n    vestingValue\n    totalVested\n    totalLapsed\n    totalOffered\n  }\n  esss(organisationId: $organisationId, page: $page, itemsPerPage: $itemsPerPage) {\n    name\n    vestingValue\n    totalVested\n    totalLapsed\n    totalOffered\n  }\n}\n    `;\n\n/**\n * __useDashboardIncentivePlansQuery__\n *\n * To run a query within a React component, call `useDashboardIncentivePlansQuery` and pass it any options that fit your needs.\n * When your component renders, `useDashboardIncentivePlansQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDashboardIncentivePlansQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useDashboardIncentivePlansQuery(baseOptions: Apollo.QueryHookOptions<DashboardIncentivePlansQuery, DashboardIncentivePlansQueryVariables> & ({ variables: DashboardIncentivePlansQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DashboardIncentivePlansQuery, DashboardIncentivePlansQueryVariables>(DashboardIncentivePlansDocument, options);\n      }\nexport function useDashboardIncentivePlansLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DashboardIncentivePlansQuery, DashboardIncentivePlansQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DashboardIncentivePlansQuery, DashboardIncentivePlansQueryVariables>(DashboardIncentivePlansDocument, options);\n        }\nexport function useDashboardIncentivePlansSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DashboardIncentivePlansQuery, DashboardIncentivePlansQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DashboardIncentivePlansQuery, DashboardIncentivePlansQueryVariables>(DashboardIncentivePlansDocument, options);\n        }\nexport type DashboardIncentivePlansQueryHookResult = ReturnType<typeof useDashboardIncentivePlansQuery>;\nexport type DashboardIncentivePlansLazyQueryHookResult = ReturnType<typeof useDashboardIncentivePlansLazyQuery>;\nexport type DashboardIncentivePlansSuspenseQueryHookResult = ReturnType<typeof useDashboardIncentivePlansSuspenseQuery>;\nexport type DashboardIncentivePlansQueryResult = Apollo.QueryResult<DashboardIncentivePlansQuery, DashboardIncentivePlansQueryVariables>;\nexport function refetchDashboardIncentivePlansQuery(variables: DashboardIncentivePlansQueryVariables) {\n      return { query: DashboardIncentivePlansDocument, variables: variables };\n    }\nexport const DebugInvalidateShareholdersPerQuarterCacheDocument: TypedDocumentNode<DebugInvalidateShareholdersPerQuarterCacheQuery, DebugInvalidateShareholdersPerQuarterCacheQueryVariables> = gql`\n  query debugInvalidateShareholdersPerQuarterCache($organisationId: String!) {\n  debugInvalidateShareholdersPerQuarterCache(organisationId: $organisationId)\n}\n    `;\n\n/**\n * __useDebugInvalidateShareholdersPerQuarterCacheQuery__\n *\n * To run a query within a React component, call `useDebugInvalidateShareholdersPerQuarterCacheQuery` and pass it any options that fit your needs.\n * When your component renders, `useDebugInvalidateShareholdersPerQuarterCacheQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDebugInvalidateShareholdersPerQuarterCacheQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useDebugInvalidateShareholdersPerQuarterCacheQuery(baseOptions: Apollo.QueryHookOptions<DebugInvalidateShareholdersPerQuarterCacheQuery, DebugInvalidateShareholdersPerQuarterCacheQueryVariables> & ({ variables: DebugInvalidateShareholdersPerQuarterCacheQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DebugInvalidateShareholdersPerQuarterCacheQuery, DebugInvalidateShareholdersPerQuarterCacheQueryVariables>(DebugInvalidateShareholdersPerQuarterCacheDocument, options);\n      }\nexport function useDebugInvalidateShareholdersPerQuarterCacheLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DebugInvalidateShareholdersPerQuarterCacheQuery, DebugInvalidateShareholdersPerQuarterCacheQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DebugInvalidateShareholdersPerQuarterCacheQuery, DebugInvalidateShareholdersPerQuarterCacheQueryVariables>(DebugInvalidateShareholdersPerQuarterCacheDocument, options);\n        }\nexport function useDebugInvalidateShareholdersPerQuarterCacheSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DebugInvalidateShareholdersPerQuarterCacheQuery, DebugInvalidateShareholdersPerQuarterCacheQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DebugInvalidateShareholdersPerQuarterCacheQuery, DebugInvalidateShareholdersPerQuarterCacheQueryVariables>(DebugInvalidateShareholdersPerQuarterCacheDocument, options);\n        }\nexport type DebugInvalidateShareholdersPerQuarterCacheQueryHookResult = ReturnType<typeof useDebugInvalidateShareholdersPerQuarterCacheQuery>;\nexport type DebugInvalidateShareholdersPerQuarterCacheLazyQueryHookResult = ReturnType<typeof useDebugInvalidateShareholdersPerQuarterCacheLazyQuery>;\nexport type DebugInvalidateShareholdersPerQuarterCacheSuspenseQueryHookResult = ReturnType<typeof useDebugInvalidateShareholdersPerQuarterCacheSuspenseQuery>;\nexport type DebugInvalidateShareholdersPerQuarterCacheQueryResult = Apollo.QueryResult<DebugInvalidateShareholdersPerQuarterCacheQuery, DebugInvalidateShareholdersPerQuarterCacheQueryVariables>;\nexport function refetchDebugInvalidateShareholdersPerQuarterCacheQuery(variables: DebugInvalidateShareholdersPerQuarterCacheQueryVariables) {\n      return { query: DebugInvalidateShareholdersPerQuarterCacheDocument, variables: variables };\n    }\nexport const EchoPublicDocument: TypedDocumentNode<EchoPublicQuery, EchoPublicQueryVariables> = gql`\n  query echoPublic($echoStr: String) {\n  echoPublic(echoStr: $echoStr)\n}\n    `;\n\n/**\n * __useEchoPublicQuery__\n *\n * To run a query within a React component, call `useEchoPublicQuery` and pass it any options that fit your needs.\n * When your component renders, `useEchoPublicQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useEchoPublicQuery({\n *   variables: {\n *      echoStr: // value for 'echoStr'\n *   },\n * });\n */\nexport function useEchoPublicQuery(baseOptions?: Apollo.QueryHookOptions<EchoPublicQuery, EchoPublicQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<EchoPublicQuery, EchoPublicQueryVariables>(EchoPublicDocument, options);\n      }\nexport function useEchoPublicLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EchoPublicQuery, EchoPublicQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<EchoPublicQuery, EchoPublicQueryVariables>(EchoPublicDocument, options);\n        }\nexport function useEchoPublicSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<EchoPublicQuery, EchoPublicQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<EchoPublicQuery, EchoPublicQueryVariables>(EchoPublicDocument, options);\n        }\nexport type EchoPublicQueryHookResult = ReturnType<typeof useEchoPublicQuery>;\nexport type EchoPublicLazyQueryHookResult = ReturnType<typeof useEchoPublicLazyQuery>;\nexport type EchoPublicSuspenseQueryHookResult = ReturnType<typeof useEchoPublicSuspenseQuery>;\nexport type EchoPublicQueryResult = Apollo.QueryResult<EchoPublicQuery, EchoPublicQueryVariables>;\nexport function refetchEchoPublicQuery(variables?: EchoPublicQueryVariables) {\n      return { query: EchoPublicDocument, variables: variables };\n    }\nexport const EchoPrivateDocument: TypedDocumentNode<EchoPrivateQuery, EchoPrivateQueryVariables> = gql`\n  query echoPrivate($echoStr: String) {\n  echoPrivate(echoStr: $echoStr)\n}\n    `;\n\n/**\n * __useEchoPrivateQuery__\n *\n * To run a query within a React component, call `useEchoPrivateQuery` and pass it any options that fit your needs.\n * When your component renders, `useEchoPrivateQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useEchoPrivateQuery({\n *   variables: {\n *      echoStr: // value for 'echoStr'\n *   },\n * });\n */\nexport function useEchoPrivateQuery(baseOptions?: Apollo.QueryHookOptions<EchoPrivateQuery, EchoPrivateQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<EchoPrivateQuery, EchoPrivateQueryVariables>(EchoPrivateDocument, options);\n      }\nexport function useEchoPrivateLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EchoPrivateQuery, EchoPrivateQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<EchoPrivateQuery, EchoPrivateQueryVariables>(EchoPrivateDocument, options);\n        }\nexport function useEchoPrivateSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<EchoPrivateQuery, EchoPrivateQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<EchoPrivateQuery, EchoPrivateQueryVariables>(EchoPrivateDocument, options);\n        }\nexport type EchoPrivateQueryHookResult = ReturnType<typeof useEchoPrivateQuery>;\nexport type EchoPrivateLazyQueryHookResult = ReturnType<typeof useEchoPrivateLazyQuery>;\nexport type EchoPrivateSuspenseQueryHookResult = ReturnType<typeof useEchoPrivateSuspenseQuery>;\nexport type EchoPrivateQueryResult = Apollo.QueryResult<EchoPrivateQuery, EchoPrivateQueryVariables>;\nexport function refetchEchoPrivateQuery(variables?: EchoPrivateQueryVariables) {\n      return { query: EchoPrivateDocument, variables: variables };\n    }\nexport const DebugClearDailyVestCacheDocument: TypedDocumentNode<DebugClearDailyVestCacheQuery, DebugClearDailyVestCacheQueryVariables> = gql`\n  query debugClearDailyVestCache {\n  debugClearDailyVestCache\n}\n    `;\n\n/**\n * __useDebugClearDailyVestCacheQuery__\n *\n * To run a query within a React component, call `useDebugClearDailyVestCacheQuery` and pass it any options that fit your needs.\n * When your component renders, `useDebugClearDailyVestCacheQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDebugClearDailyVestCacheQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useDebugClearDailyVestCacheQuery(baseOptions?: Apollo.QueryHookOptions<DebugClearDailyVestCacheQuery, DebugClearDailyVestCacheQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DebugClearDailyVestCacheQuery, DebugClearDailyVestCacheQueryVariables>(DebugClearDailyVestCacheDocument, options);\n      }\nexport function useDebugClearDailyVestCacheLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DebugClearDailyVestCacheQuery, DebugClearDailyVestCacheQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DebugClearDailyVestCacheQuery, DebugClearDailyVestCacheQueryVariables>(DebugClearDailyVestCacheDocument, options);\n        }\nexport function useDebugClearDailyVestCacheSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DebugClearDailyVestCacheQuery, DebugClearDailyVestCacheQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DebugClearDailyVestCacheQuery, DebugClearDailyVestCacheQueryVariables>(DebugClearDailyVestCacheDocument, options);\n        }\nexport type DebugClearDailyVestCacheQueryHookResult = ReturnType<typeof useDebugClearDailyVestCacheQuery>;\nexport type DebugClearDailyVestCacheLazyQueryHookResult = ReturnType<typeof useDebugClearDailyVestCacheLazyQuery>;\nexport type DebugClearDailyVestCacheSuspenseQueryHookResult = ReturnType<typeof useDebugClearDailyVestCacheSuspenseQuery>;\nexport type DebugClearDailyVestCacheQueryResult = Apollo.QueryResult<DebugClearDailyVestCacheQuery, DebugClearDailyVestCacheQueryVariables>;\nexport function refetchDebugClearDailyVestCacheQuery(variables?: DebugClearDailyVestCacheQueryVariables) {\n      return { query: DebugClearDailyVestCacheDocument, variables: variables };\n    }\nexport const DebugCacheStatisticsDocument: TypedDocumentNode<DebugCacheStatisticsQuery, DebugCacheStatisticsQueryVariables> = gql`\n  query debugCacheStatistics {\n  debugCacheStatistics\n}\n    `;\n\n/**\n * __useDebugCacheStatisticsQuery__\n *\n * To run a query within a React component, call `useDebugCacheStatisticsQuery` and pass it any options that fit your needs.\n * When your component renders, `useDebugCacheStatisticsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDebugCacheStatisticsQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useDebugCacheStatisticsQuery(baseOptions?: Apollo.QueryHookOptions<DebugCacheStatisticsQuery, DebugCacheStatisticsQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DebugCacheStatisticsQuery, DebugCacheStatisticsQueryVariables>(DebugCacheStatisticsDocument, options);\n      }\nexport function useDebugCacheStatisticsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DebugCacheStatisticsQuery, DebugCacheStatisticsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DebugCacheStatisticsQuery, DebugCacheStatisticsQueryVariables>(DebugCacheStatisticsDocument, options);\n        }\nexport function useDebugCacheStatisticsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DebugCacheStatisticsQuery, DebugCacheStatisticsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DebugCacheStatisticsQuery, DebugCacheStatisticsQueryVariables>(DebugCacheStatisticsDocument, options);\n        }\nexport type DebugCacheStatisticsQueryHookResult = ReturnType<typeof useDebugCacheStatisticsQuery>;\nexport type DebugCacheStatisticsLazyQueryHookResult = ReturnType<typeof useDebugCacheStatisticsLazyQuery>;\nexport type DebugCacheStatisticsSuspenseQueryHookResult = ReturnType<typeof useDebugCacheStatisticsSuspenseQuery>;\nexport type DebugCacheStatisticsQueryResult = Apollo.QueryResult<DebugCacheStatisticsQuery, DebugCacheStatisticsQueryVariables>;\nexport function refetchDebugCacheStatisticsQuery(variables?: DebugCacheStatisticsQueryVariables) {\n      return { query: DebugCacheStatisticsDocument, variables: variables };\n    }\nexport const DebugInvalidateCacheDocument: TypedDocumentNode<DebugInvalidateCacheQuery, DebugInvalidateCacheQueryVariables> = gql`\n  query debugInvalidateCache($organisationId: String!) {\n  debugInvalidateCache(organisationId: $organisationId)\n}\n    `;\n\n/**\n * __useDebugInvalidateCacheQuery__\n *\n * To run a query within a React component, call `useDebugInvalidateCacheQuery` and pass it any options that fit your needs.\n * When your component renders, `useDebugInvalidateCacheQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDebugInvalidateCacheQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useDebugInvalidateCacheQuery(baseOptions: Apollo.QueryHookOptions<DebugInvalidateCacheQuery, DebugInvalidateCacheQueryVariables> & ({ variables: DebugInvalidateCacheQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DebugInvalidateCacheQuery, DebugInvalidateCacheQueryVariables>(DebugInvalidateCacheDocument, options);\n      }\nexport function useDebugInvalidateCacheLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DebugInvalidateCacheQuery, DebugInvalidateCacheQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DebugInvalidateCacheQuery, DebugInvalidateCacheQueryVariables>(DebugInvalidateCacheDocument, options);\n        }\nexport function useDebugInvalidateCacheSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DebugInvalidateCacheQuery, DebugInvalidateCacheQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DebugInvalidateCacheQuery, DebugInvalidateCacheQueryVariables>(DebugInvalidateCacheDocument, options);\n        }\nexport type DebugInvalidateCacheQueryHookResult = ReturnType<typeof useDebugInvalidateCacheQuery>;\nexport type DebugInvalidateCacheLazyQueryHookResult = ReturnType<typeof useDebugInvalidateCacheLazyQuery>;\nexport type DebugInvalidateCacheSuspenseQueryHookResult = ReturnType<typeof useDebugInvalidateCacheSuspenseQuery>;\nexport type DebugInvalidateCacheQueryResult = Apollo.QueryResult<DebugInvalidateCacheQuery, DebugInvalidateCacheQueryVariables>;\nexport function refetchDebugInvalidateCacheQuery(variables: DebugInvalidateCacheQueryVariables) {\n      return { query: DebugInvalidateCacheDocument, variables: variables };\n    }\nexport const DebugTriggerEndedDisclosuresDocument: TypedDocumentNode<DebugTriggerEndedDisclosuresQuery, DebugTriggerEndedDisclosuresQueryVariables> = gql`\n  query debugTriggerEndedDisclosures {\n  debugTriggerEndedDisclosures\n}\n    `;\n\n/**\n * __useDebugTriggerEndedDisclosuresQuery__\n *\n * To run a query within a React component, call `useDebugTriggerEndedDisclosuresQuery` and pass it any options that fit your needs.\n * When your component renders, `useDebugTriggerEndedDisclosuresQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDebugTriggerEndedDisclosuresQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useDebugTriggerEndedDisclosuresQuery(baseOptions?: Apollo.QueryHookOptions<DebugTriggerEndedDisclosuresQuery, DebugTriggerEndedDisclosuresQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DebugTriggerEndedDisclosuresQuery, DebugTriggerEndedDisclosuresQueryVariables>(DebugTriggerEndedDisclosuresDocument, options);\n      }\nexport function useDebugTriggerEndedDisclosuresLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DebugTriggerEndedDisclosuresQuery, DebugTriggerEndedDisclosuresQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DebugTriggerEndedDisclosuresQuery, DebugTriggerEndedDisclosuresQueryVariables>(DebugTriggerEndedDisclosuresDocument, options);\n        }\nexport function useDebugTriggerEndedDisclosuresSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DebugTriggerEndedDisclosuresQuery, DebugTriggerEndedDisclosuresQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DebugTriggerEndedDisclosuresQuery, DebugTriggerEndedDisclosuresQueryVariables>(DebugTriggerEndedDisclosuresDocument, options);\n        }\nexport type DebugTriggerEndedDisclosuresQueryHookResult = ReturnType<typeof useDebugTriggerEndedDisclosuresQuery>;\nexport type DebugTriggerEndedDisclosuresLazyQueryHookResult = ReturnType<typeof useDebugTriggerEndedDisclosuresLazyQuery>;\nexport type DebugTriggerEndedDisclosuresSuspenseQueryHookResult = ReturnType<typeof useDebugTriggerEndedDisclosuresSuspenseQuery>;\nexport type DebugTriggerEndedDisclosuresQueryResult = Apollo.QueryResult<DebugTriggerEndedDisclosuresQuery, DebugTriggerEndedDisclosuresQueryVariables>;\nexport function refetchDebugTriggerEndedDisclosuresQuery(variables?: DebugTriggerEndedDisclosuresQueryVariables) {\n      return { query: DebugTriggerEndedDisclosuresDocument, variables: variables };\n    }\nexport const DebugInvalidateStripePlanCacheDocument: TypedDocumentNode<DebugInvalidateStripePlanCacheQuery, DebugInvalidateStripePlanCacheQueryVariables> = gql`\n  query debugInvalidateStripePlanCache {\n  debugInvalidateStripeTiersAndAddonsCache\n}\n    `;\n\n/**\n * __useDebugInvalidateStripePlanCacheQuery__\n *\n * To run a query within a React component, call `useDebugInvalidateStripePlanCacheQuery` and pass it any options that fit your needs.\n * When your component renders, `useDebugInvalidateStripePlanCacheQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDebugInvalidateStripePlanCacheQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useDebugInvalidateStripePlanCacheQuery(baseOptions?: Apollo.QueryHookOptions<DebugInvalidateStripePlanCacheQuery, DebugInvalidateStripePlanCacheQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DebugInvalidateStripePlanCacheQuery, DebugInvalidateStripePlanCacheQueryVariables>(DebugInvalidateStripePlanCacheDocument, options);\n      }\nexport function useDebugInvalidateStripePlanCacheLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DebugInvalidateStripePlanCacheQuery, DebugInvalidateStripePlanCacheQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DebugInvalidateStripePlanCacheQuery, DebugInvalidateStripePlanCacheQueryVariables>(DebugInvalidateStripePlanCacheDocument, options);\n        }\nexport function useDebugInvalidateStripePlanCacheSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DebugInvalidateStripePlanCacheQuery, DebugInvalidateStripePlanCacheQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DebugInvalidateStripePlanCacheQuery, DebugInvalidateStripePlanCacheQueryVariables>(DebugInvalidateStripePlanCacheDocument, options);\n        }\nexport type DebugInvalidateStripePlanCacheQueryHookResult = ReturnType<typeof useDebugInvalidateStripePlanCacheQuery>;\nexport type DebugInvalidateStripePlanCacheLazyQueryHookResult = ReturnType<typeof useDebugInvalidateStripePlanCacheLazyQuery>;\nexport type DebugInvalidateStripePlanCacheSuspenseQueryHookResult = ReturnType<typeof useDebugInvalidateStripePlanCacheSuspenseQuery>;\nexport type DebugInvalidateStripePlanCacheQueryResult = Apollo.QueryResult<DebugInvalidateStripePlanCacheQuery, DebugInvalidateStripePlanCacheQueryVariables>;\nexport function refetchDebugInvalidateStripePlanCacheQuery(variables?: DebugInvalidateStripePlanCacheQueryVariables) {\n      return { query: DebugInvalidateStripePlanCacheDocument, variables: variables };\n    }\nexport const DebugRefreshLicenseDocument: TypedDocumentNode<DebugRefreshLicenseMutation, DebugRefreshLicenseMutationVariables> = gql`\n  mutation debugRefreshLicense($organisationId: OrganisationCakeType!) {\n  debugRefreshLicense(organisation: $organisationId) {\n    internalId\n    hasEquityPlansEnabled\n    esopOfferCount\n    essOfferCount\n    rsuOfferCount\n    warrantOfferCount\n    maxInvestors\n    investorCount\n    delinquent\n    isPaused\n  }\n}\n    `;\nexport type DebugRefreshLicenseMutationFn = Apollo.MutationFunction<DebugRefreshLicenseMutation, DebugRefreshLicenseMutationVariables>;\n\n/**\n * __useDebugRefreshLicenseMutation__\n *\n * To run a mutation, you first call `useDebugRefreshLicenseMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDebugRefreshLicenseMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [debugRefreshLicenseMutation, { data, loading, error }] = useDebugRefreshLicenseMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useDebugRefreshLicenseMutation(baseOptions?: Apollo.MutationHookOptions<DebugRefreshLicenseMutation, DebugRefreshLicenseMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DebugRefreshLicenseMutation, DebugRefreshLicenseMutationVariables>(DebugRefreshLicenseDocument, options);\n      }\nexport type DebugRefreshLicenseMutationHookResult = ReturnType<typeof useDebugRefreshLicenseMutation>;\nexport type DebugRefreshLicenseMutationResult = Apollo.MutationResult<DebugRefreshLicenseMutation>;\nexport type DebugRefreshLicenseMutationOptions = Apollo.BaseMutationOptions<DebugRefreshLicenseMutation, DebugRefreshLicenseMutationVariables>;\nexport const DebugReportUsageDocument: TypedDocumentNode<DebugReportUsageMutation, DebugReportUsageMutationVariables> = gql`\n  mutation debugReportUsage($organisation: OrganisationCakeType!) {\n  debugReportUsage(organisation: $organisation)\n}\n    `;\nexport type DebugReportUsageMutationFn = Apollo.MutationFunction<DebugReportUsageMutation, DebugReportUsageMutationVariables>;\n\n/**\n * __useDebugReportUsageMutation__\n *\n * To run a mutation, you first call `useDebugReportUsageMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDebugReportUsageMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [debugReportUsageMutation, { data, loading, error }] = useDebugReportUsageMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useDebugReportUsageMutation(baseOptions?: Apollo.MutationHookOptions<DebugReportUsageMutation, DebugReportUsageMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DebugReportUsageMutation, DebugReportUsageMutationVariables>(DebugReportUsageDocument, options);\n      }\nexport type DebugReportUsageMutationHookResult = ReturnType<typeof useDebugReportUsageMutation>;\nexport type DebugReportUsageMutationResult = Apollo.MutationResult<DebugReportUsageMutation>;\nexport type DebugReportUsageMutationOptions = Apollo.BaseMutationOptions<DebugReportUsageMutation, DebugReportUsageMutationVariables>;\nexport const DebugConsolidateCapTableDocument: TypedDocumentNode<DebugConsolidateCapTableQuery, DebugConsolidateCapTableQueryVariables> = gql`\n  query debugConsolidateCapTable($organisation: OrganisationCakeType!) {\n  debugConsolidateCapTable(organisation: $organisation)\n}\n    `;\n\n/**\n * __useDebugConsolidateCapTableQuery__\n *\n * To run a query within a React component, call `useDebugConsolidateCapTableQuery` and pass it any options that fit your needs.\n * When your component renders, `useDebugConsolidateCapTableQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDebugConsolidateCapTableQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useDebugConsolidateCapTableQuery(baseOptions: Apollo.QueryHookOptions<DebugConsolidateCapTableQuery, DebugConsolidateCapTableQueryVariables> & ({ variables: DebugConsolidateCapTableQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DebugConsolidateCapTableQuery, DebugConsolidateCapTableQueryVariables>(DebugConsolidateCapTableDocument, options);\n      }\nexport function useDebugConsolidateCapTableLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DebugConsolidateCapTableQuery, DebugConsolidateCapTableQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DebugConsolidateCapTableQuery, DebugConsolidateCapTableQueryVariables>(DebugConsolidateCapTableDocument, options);\n        }\nexport function useDebugConsolidateCapTableSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DebugConsolidateCapTableQuery, DebugConsolidateCapTableQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DebugConsolidateCapTableQuery, DebugConsolidateCapTableQueryVariables>(DebugConsolidateCapTableDocument, options);\n        }\nexport type DebugConsolidateCapTableQueryHookResult = ReturnType<typeof useDebugConsolidateCapTableQuery>;\nexport type DebugConsolidateCapTableLazyQueryHookResult = ReturnType<typeof useDebugConsolidateCapTableLazyQuery>;\nexport type DebugConsolidateCapTableSuspenseQueryHookResult = ReturnType<typeof useDebugConsolidateCapTableSuspenseQuery>;\nexport type DebugConsolidateCapTableQueryResult = Apollo.QueryResult<DebugConsolidateCapTableQuery, DebugConsolidateCapTableQueryVariables>;\nexport function refetchDebugConsolidateCapTableQuery(variables: DebugConsolidateCapTableQueryVariables) {\n      return { query: DebugConsolidateCapTableDocument, variables: variables };\n    }\nexport const DebugEsopCalendarDocument: TypedDocumentNode<DebugEsopCalendarQuery, DebugEsopCalendarQueryVariables> = gql`\n  query debugEsopCalendar($offer: EsopOfferCakeType!, $merged: Boolean, $sampleEntries: Boolean) {\n  debugEsopCalendar(offer: $offer, merged: $merged, sampleEntries: $sampleEntries) {\n    entries {\n      date\n      accumulated\n      vestingValue\n      lapsed\n      entryType\n      transactionId\n    }\n    vestStartDate\n    count\n  }\n}\n    `;\n\n/**\n * __useDebugEsopCalendarQuery__\n *\n * To run a query within a React component, call `useDebugEsopCalendarQuery` and pass it any options that fit your needs.\n * When your component renders, `useDebugEsopCalendarQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDebugEsopCalendarQuery({\n *   variables: {\n *      offer: // value for 'offer'\n *      merged: // value for 'merged'\n *      sampleEntries: // value for 'sampleEntries'\n *   },\n * });\n */\nexport function useDebugEsopCalendarQuery(baseOptions: Apollo.QueryHookOptions<DebugEsopCalendarQuery, DebugEsopCalendarQueryVariables> & ({ variables: DebugEsopCalendarQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DebugEsopCalendarQuery, DebugEsopCalendarQueryVariables>(DebugEsopCalendarDocument, options);\n      }\nexport function useDebugEsopCalendarLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DebugEsopCalendarQuery, DebugEsopCalendarQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DebugEsopCalendarQuery, DebugEsopCalendarQueryVariables>(DebugEsopCalendarDocument, options);\n        }\nexport function useDebugEsopCalendarSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DebugEsopCalendarQuery, DebugEsopCalendarQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DebugEsopCalendarQuery, DebugEsopCalendarQueryVariables>(DebugEsopCalendarDocument, options);\n        }\nexport type DebugEsopCalendarQueryHookResult = ReturnType<typeof useDebugEsopCalendarQuery>;\nexport type DebugEsopCalendarLazyQueryHookResult = ReturnType<typeof useDebugEsopCalendarLazyQuery>;\nexport type DebugEsopCalendarSuspenseQueryHookResult = ReturnType<typeof useDebugEsopCalendarSuspenseQuery>;\nexport type DebugEsopCalendarQueryResult = Apollo.QueryResult<DebugEsopCalendarQuery, DebugEsopCalendarQueryVariables>;\nexport function refetchDebugEsopCalendarQuery(variables: DebugEsopCalendarQueryVariables) {\n      return { query: DebugEsopCalendarDocument, variables: variables };\n    }\nexport const DebugEssCalendarDocument: TypedDocumentNode<DebugEssCalendarQuery, DebugEssCalendarQueryVariables> = gql`\n  query debugEssCalendar($offer: EssOfferCakeType!, $merged: Boolean, $sampleEntries: Boolean, $useLegacy: Boolean) {\n  debugEssCalendar(\n    offer: $offer\n    merged: $merged\n    sampleEntries: $sampleEntries\n    useLegacy: $useLegacy\n  ) {\n    entries {\n      date\n      accumulated\n      vestingValue\n      lapsed\n      entryType\n      transactionId\n    }\n    vestStartDate\n    count\n  }\n}\n    `;\n\n/**\n * __useDebugEssCalendarQuery__\n *\n * To run a query within a React component, call `useDebugEssCalendarQuery` and pass it any options that fit your needs.\n * When your component renders, `useDebugEssCalendarQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useDebugEssCalendarQuery({\n *   variables: {\n *      offer: // value for 'offer'\n *      merged: // value for 'merged'\n *      sampleEntries: // value for 'sampleEntries'\n *      useLegacy: // value for 'useLegacy'\n *   },\n * });\n */\nexport function useDebugEssCalendarQuery(baseOptions: Apollo.QueryHookOptions<DebugEssCalendarQuery, DebugEssCalendarQueryVariables> & ({ variables: DebugEssCalendarQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<DebugEssCalendarQuery, DebugEssCalendarQueryVariables>(DebugEssCalendarDocument, options);\n      }\nexport function useDebugEssCalendarLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DebugEssCalendarQuery, DebugEssCalendarQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<DebugEssCalendarQuery, DebugEssCalendarQueryVariables>(DebugEssCalendarDocument, options);\n        }\nexport function useDebugEssCalendarSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<DebugEssCalendarQuery, DebugEssCalendarQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<DebugEssCalendarQuery, DebugEssCalendarQueryVariables>(DebugEssCalendarDocument, options);\n        }\nexport type DebugEssCalendarQueryHookResult = ReturnType<typeof useDebugEssCalendarQuery>;\nexport type DebugEssCalendarLazyQueryHookResult = ReturnType<typeof useDebugEssCalendarLazyQuery>;\nexport type DebugEssCalendarSuspenseQueryHookResult = ReturnType<typeof useDebugEssCalendarSuspenseQuery>;\nexport type DebugEssCalendarQueryResult = Apollo.QueryResult<DebugEssCalendarQuery, DebugEssCalendarQueryVariables>;\nexport function refetchDebugEssCalendarQuery(variables: DebugEssCalendarQueryVariables) {\n      return { query: DebugEssCalendarDocument, variables: variables };\n    }\nexport const DebugRefreshExchangeRatesDocument: TypedDocumentNode<DebugRefreshExchangeRatesMutation, DebugRefreshExchangeRatesMutationVariables> = gql`\n  mutation debugRefreshExchangeRates {\n  debugRefreshExchangeRates\n}\n    `;\nexport type DebugRefreshExchangeRatesMutationFn = Apollo.MutationFunction<DebugRefreshExchangeRatesMutation, DebugRefreshExchangeRatesMutationVariables>;\n\n/**\n * __useDebugRefreshExchangeRatesMutation__\n *\n * To run a mutation, you first call `useDebugRefreshExchangeRatesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDebugRefreshExchangeRatesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [debugRefreshExchangeRatesMutation, { data, loading, error }] = useDebugRefreshExchangeRatesMutation({\n *   variables: {\n *   },\n * });\n */\nexport function useDebugRefreshExchangeRatesMutation(baseOptions?: Apollo.MutationHookOptions<DebugRefreshExchangeRatesMutation, DebugRefreshExchangeRatesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DebugRefreshExchangeRatesMutation, DebugRefreshExchangeRatesMutationVariables>(DebugRefreshExchangeRatesDocument, options);\n      }\nexport type DebugRefreshExchangeRatesMutationHookResult = ReturnType<typeof useDebugRefreshExchangeRatesMutation>;\nexport type DebugRefreshExchangeRatesMutationResult = Apollo.MutationResult<DebugRefreshExchangeRatesMutation>;\nexport type DebugRefreshExchangeRatesMutationOptions = Apollo.BaseMutationOptions<DebugRefreshExchangeRatesMutation, DebugRefreshExchangeRatesMutationVariables>;\nexport const GetDocumentDocument: TypedDocumentNode<GetDocumentQuery, GetDocumentQueryVariables> = gql`\n  query getDocument($documentId: DocumentCakeType!) {\n  document(document: $documentId) {\n    id\n    name\n    modified\n    extension\n    type\n    status\n    contractType\n    signatureEmailSubject\n    signatureEmailBody\n    signingEnvelopeId\n    signatures {\n      name\n      email\n      status\n      extra\n    }\n    access {\n      id\n      isShareholder\n      name\n      email\n      avatar\n      isDirectPermission\n    }\n  }\n}\n    `;\n\n/**\n * __useGetDocumentQuery__\n *\n * To run a query within a React component, call `useGetDocumentQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDocumentQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDocumentQuery({\n *   variables: {\n *      documentId: // value for 'documentId'\n *   },\n * });\n */\nexport function useGetDocumentQuery(baseOptions: Apollo.QueryHookOptions<GetDocumentQuery, GetDocumentQueryVariables> & ({ variables: GetDocumentQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDocumentQuery, GetDocumentQueryVariables>(GetDocumentDocument, options);\n      }\nexport function useGetDocumentLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDocumentQuery, GetDocumentQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDocumentQuery, GetDocumentQueryVariables>(GetDocumentDocument, options);\n        }\nexport function useGetDocumentSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDocumentQuery, GetDocumentQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDocumentQuery, GetDocumentQueryVariables>(GetDocumentDocument, options);\n        }\nexport type GetDocumentQueryHookResult = ReturnType<typeof useGetDocumentQuery>;\nexport type GetDocumentLazyQueryHookResult = ReturnType<typeof useGetDocumentLazyQuery>;\nexport type GetDocumentSuspenseQueryHookResult = ReturnType<typeof useGetDocumentSuspenseQuery>;\nexport type GetDocumentQueryResult = Apollo.QueryResult<GetDocumentQuery, GetDocumentQueryVariables>;\nexport function refetchGetDocumentQuery(variables: GetDocumentQueryVariables) {\n      return { query: GetDocumentDocument, variables: variables };\n    }\nexport const GetFolderPathDocument: TypedDocumentNode<GetFolderPathQuery, GetFolderPathQueryVariables> = gql`\n  query getFolderPath($documentId: DocumentCakeType!) {\n  document(document: $documentId) {\n    path {\n      id\n      name\n      fileCount\n      folderCount\n      isSystem\n    }\n  }\n}\n    `;\n\n/**\n * __useGetFolderPathQuery__\n *\n * To run a query within a React component, call `useGetFolderPathQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetFolderPathQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetFolderPathQuery({\n *   variables: {\n *      documentId: // value for 'documentId'\n *   },\n * });\n */\nexport function useGetFolderPathQuery(baseOptions: Apollo.QueryHookOptions<GetFolderPathQuery, GetFolderPathQueryVariables> & ({ variables: GetFolderPathQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetFolderPathQuery, GetFolderPathQueryVariables>(GetFolderPathDocument, options);\n      }\nexport function useGetFolderPathLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetFolderPathQuery, GetFolderPathQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetFolderPathQuery, GetFolderPathQueryVariables>(GetFolderPathDocument, options);\n        }\nexport function useGetFolderPathSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetFolderPathQuery, GetFolderPathQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetFolderPathQuery, GetFolderPathQueryVariables>(GetFolderPathDocument, options);\n        }\nexport type GetFolderPathQueryHookResult = ReturnType<typeof useGetFolderPathQuery>;\nexport type GetFolderPathLazyQueryHookResult = ReturnType<typeof useGetFolderPathLazyQuery>;\nexport type GetFolderPathSuspenseQueryHookResult = ReturnType<typeof useGetFolderPathSuspenseQuery>;\nexport type GetFolderPathQueryResult = Apollo.QueryResult<GetFolderPathQuery, GetFolderPathQueryVariables>;\nexport function refetchGetFolderPathQuery(variables: GetFolderPathQueryVariables) {\n      return { query: GetFolderPathDocument, variables: variables };\n    }\nexport const ListFoldersDocument: TypedDocumentNode<ListFoldersQuery, ListFoldersQueryVariables> = gql`\n  query listFolders($organisationId: UUID!, $documentId: UUID!) {\n  listFolders(organisationId: $organisationId, parentId: $documentId) {\n    id\n    name\n    fileCount\n    folderCount\n    isSystem\n  }\n}\n    `;\n\n/**\n * __useListFoldersQuery__\n *\n * To run a query within a React component, call `useListFoldersQuery` and pass it any options that fit your needs.\n * When your component renders, `useListFoldersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useListFoldersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      documentId: // value for 'documentId'\n *   },\n * });\n */\nexport function useListFoldersQuery(baseOptions: Apollo.QueryHookOptions<ListFoldersQuery, ListFoldersQueryVariables> & ({ variables: ListFoldersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ListFoldersQuery, ListFoldersQueryVariables>(ListFoldersDocument, options);\n      }\nexport function useListFoldersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ListFoldersQuery, ListFoldersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ListFoldersQuery, ListFoldersQueryVariables>(ListFoldersDocument, options);\n        }\nexport function useListFoldersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ListFoldersQuery, ListFoldersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ListFoldersQuery, ListFoldersQueryVariables>(ListFoldersDocument, options);\n        }\nexport type ListFoldersQueryHookResult = ReturnType<typeof useListFoldersQuery>;\nexport type ListFoldersLazyQueryHookResult = ReturnType<typeof useListFoldersLazyQuery>;\nexport type ListFoldersSuspenseQueryHookResult = ReturnType<typeof useListFoldersSuspenseQuery>;\nexport type ListFoldersQueryResult = Apollo.QueryResult<ListFoldersQuery, ListFoldersQueryVariables>;\nexport function refetchListFoldersQuery(variables: ListFoldersQueryVariables) {\n      return { query: ListFoldersDocument, variables: variables };\n    }\nexport const ListFilesDocument: TypedDocumentNode<ListFilesQuery, ListFilesQueryVariables> = gql`\n  query listFiles($organisationId: UUID!, $documentId: UUID!, $search: String, $page: Int, $itemsPerPage: Int) {\n  listFiles(\n    organisationId: $organisationId\n    parentId: $documentId\n    search: $search\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    pageData {\n      id\n      name\n      extension\n      modified\n      parent {\n        name\n      }\n    }\n    currentPage\n    count\n  }\n}\n    `;\n\n/**\n * __useListFilesQuery__\n *\n * To run a query within a React component, call `useListFilesQuery` and pass it any options that fit your needs.\n * When your component renders, `useListFilesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useListFilesQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      documentId: // value for 'documentId'\n *      search: // value for 'search'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useListFilesQuery(baseOptions: Apollo.QueryHookOptions<ListFilesQuery, ListFilesQueryVariables> & ({ variables: ListFilesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ListFilesQuery, ListFilesQueryVariables>(ListFilesDocument, options);\n      }\nexport function useListFilesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ListFilesQuery, ListFilesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ListFilesQuery, ListFilesQueryVariables>(ListFilesDocument, options);\n        }\nexport function useListFilesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ListFilesQuery, ListFilesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ListFilesQuery, ListFilesQueryVariables>(ListFilesDocument, options);\n        }\nexport type ListFilesQueryHookResult = ReturnType<typeof useListFilesQuery>;\nexport type ListFilesLazyQueryHookResult = ReturnType<typeof useListFilesLazyQuery>;\nexport type ListFilesSuspenseQueryHookResult = ReturnType<typeof useListFilesSuspenseQuery>;\nexport type ListFilesQueryResult = Apollo.QueryResult<ListFilesQuery, ListFilesQueryVariables>;\nexport function refetchListFilesQuery(variables: ListFilesQueryVariables) {\n      return { query: ListFilesDocument, variables: variables };\n    }\nexport const GetOrganisationDocumentsDocument: TypedDocumentNode<GetOrganisationDocumentsQuery, GetOrganisationDocumentsQueryVariables> = gql`\n  query getOrganisationDocuments($organisationId: UUID!, $filterType: String, $search: String, $page: Int, $itemsPerPage: Int) {\n  organisationDocuments(\n    organisationId: $organisationId\n    filterType: $filterType\n    search: $search\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    pageData {\n      id\n      modified\n      name\n      extension\n      contractType\n      signatures {\n        name\n        email\n        status\n      }\n      parent {\n        name\n      }\n      usedIn\n    }\n    currentPage\n    count\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationDocumentsQuery__\n *\n * To run a query within a React component, call `useGetOrganisationDocumentsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationDocumentsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationDocumentsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      filterType: // value for 'filterType'\n *      search: // value for 'search'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetOrganisationDocumentsQuery(baseOptions: Apollo.QueryHookOptions<GetOrganisationDocumentsQuery, GetOrganisationDocumentsQueryVariables> & ({ variables: GetOrganisationDocumentsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationDocumentsQuery, GetOrganisationDocumentsQueryVariables>(GetOrganisationDocumentsDocument, options);\n      }\nexport function useGetOrganisationDocumentsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationDocumentsQuery, GetOrganisationDocumentsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationDocumentsQuery, GetOrganisationDocumentsQueryVariables>(GetOrganisationDocumentsDocument, options);\n        }\nexport function useGetOrganisationDocumentsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationDocumentsQuery, GetOrganisationDocumentsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationDocumentsQuery, GetOrganisationDocumentsQueryVariables>(GetOrganisationDocumentsDocument, options);\n        }\nexport type GetOrganisationDocumentsQueryHookResult = ReturnType<typeof useGetOrganisationDocumentsQuery>;\nexport type GetOrganisationDocumentsLazyQueryHookResult = ReturnType<typeof useGetOrganisationDocumentsLazyQuery>;\nexport type GetOrganisationDocumentsSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationDocumentsSuspenseQuery>;\nexport type GetOrganisationDocumentsQueryResult = Apollo.QueryResult<GetOrganisationDocumentsQuery, GetOrganisationDocumentsQueryVariables>;\nexport function refetchGetOrganisationDocumentsQuery(variables: GetOrganisationDocumentsQueryVariables) {\n      return { query: GetOrganisationDocumentsDocument, variables: variables };\n    }\nexport const GetDocumentPermissionsDocument: TypedDocumentNode<GetDocumentPermissionsQuery, GetDocumentPermissionsQueryVariables> = gql`\n  query getDocumentPermissions($documentId: DocumentCakeType!) {\n  document(document: $documentId) {\n    id\n    created\n    modified\n    name\n    file\n    extension\n    access {\n      id\n      isShareholder\n      name\n      email\n      avatar\n      isDirectPermission\n    }\n  }\n}\n    `;\n\n/**\n * __useGetDocumentPermissionsQuery__\n *\n * To run a query within a React component, call `useGetDocumentPermissionsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDocumentPermissionsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDocumentPermissionsQuery({\n *   variables: {\n *      documentId: // value for 'documentId'\n *   },\n * });\n */\nexport function useGetDocumentPermissionsQuery(baseOptions: Apollo.QueryHookOptions<GetDocumentPermissionsQuery, GetDocumentPermissionsQueryVariables> & ({ variables: GetDocumentPermissionsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDocumentPermissionsQuery, GetDocumentPermissionsQueryVariables>(GetDocumentPermissionsDocument, options);\n      }\nexport function useGetDocumentPermissionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDocumentPermissionsQuery, GetDocumentPermissionsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDocumentPermissionsQuery, GetDocumentPermissionsQueryVariables>(GetDocumentPermissionsDocument, options);\n        }\nexport function useGetDocumentPermissionsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDocumentPermissionsQuery, GetDocumentPermissionsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDocumentPermissionsQuery, GetDocumentPermissionsQueryVariables>(GetDocumentPermissionsDocument, options);\n        }\nexport type GetDocumentPermissionsQueryHookResult = ReturnType<typeof useGetDocumentPermissionsQuery>;\nexport type GetDocumentPermissionsLazyQueryHookResult = ReturnType<typeof useGetDocumentPermissionsLazyQuery>;\nexport type GetDocumentPermissionsSuspenseQueryHookResult = ReturnType<typeof useGetDocumentPermissionsSuspenseQuery>;\nexport type GetDocumentPermissionsQueryResult = Apollo.QueryResult<GetDocumentPermissionsQuery, GetDocumentPermissionsQueryVariables>;\nexport function refetchGetDocumentPermissionsQuery(variables: GetDocumentPermissionsQueryVariables) {\n      return { query: GetDocumentPermissionsDocument, variables: variables };\n    }\nexport const TemplatesByContractTypeDocument: TypedDocumentNode<TemplatesByContractTypeQuery, TemplatesByContractTypeQueryVariables> = gql`\n  query templatesByContractType($organisation: OrganisationCakeType!, $contractTypes: [CleanString!]!, $country: CleanString) {\n  templatesByContractType(\n    organisation: $organisation\n    contractTypes: $contractTypes\n    country: $country\n  ) {\n    id\n    name\n    updated: modified\n  }\n}\n    `;\n\n/**\n * __useTemplatesByContractTypeQuery__\n *\n * To run a query within a React component, call `useTemplatesByContractTypeQuery` and pass it any options that fit your needs.\n * When your component renders, `useTemplatesByContractTypeQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useTemplatesByContractTypeQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      contractTypes: // value for 'contractTypes'\n *      country: // value for 'country'\n *   },\n * });\n */\nexport function useTemplatesByContractTypeQuery(baseOptions: Apollo.QueryHookOptions<TemplatesByContractTypeQuery, TemplatesByContractTypeQueryVariables> & ({ variables: TemplatesByContractTypeQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<TemplatesByContractTypeQuery, TemplatesByContractTypeQueryVariables>(TemplatesByContractTypeDocument, options);\n      }\nexport function useTemplatesByContractTypeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TemplatesByContractTypeQuery, TemplatesByContractTypeQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<TemplatesByContractTypeQuery, TemplatesByContractTypeQueryVariables>(TemplatesByContractTypeDocument, options);\n        }\nexport function useTemplatesByContractTypeSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<TemplatesByContractTypeQuery, TemplatesByContractTypeQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<TemplatesByContractTypeQuery, TemplatesByContractTypeQueryVariables>(TemplatesByContractTypeDocument, options);\n        }\nexport type TemplatesByContractTypeQueryHookResult = ReturnType<typeof useTemplatesByContractTypeQuery>;\nexport type TemplatesByContractTypeLazyQueryHookResult = ReturnType<typeof useTemplatesByContractTypeLazyQuery>;\nexport type TemplatesByContractTypeSuspenseQueryHookResult = ReturnType<typeof useTemplatesByContractTypeSuspenseQuery>;\nexport type TemplatesByContractTypeQueryResult = Apollo.QueryResult<TemplatesByContractTypeQuery, TemplatesByContractTypeQueryVariables>;\nexport function refetchTemplatesByContractTypeQuery(variables: TemplatesByContractTypeQueryVariables) {\n      return { query: TemplatesByContractTypeDocument, variables: variables };\n    }\nexport const TemplateViewLinkDocument: TypedDocumentNode<TemplateViewLinkQuery, TemplateViewLinkQueryVariables> = gql`\n  query templateViewLink($organisation: OrganisationCakeType!, $organisationId: UUID!, $contractType: CleanString!) {\n  templateViewLink(organisation: $organisation, contractType: $contractType)\n  organisation(organisationId: $organisationId) {\n    shareCertificateType\n  }\n}\n    `;\n\n/**\n * __useTemplateViewLinkQuery__\n *\n * To run a query within a React component, call `useTemplateViewLinkQuery` and pass it any options that fit your needs.\n * When your component renders, `useTemplateViewLinkQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useTemplateViewLinkQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      organisationId: // value for 'organisationId'\n *      contractType: // value for 'contractType'\n *   },\n * });\n */\nexport function useTemplateViewLinkQuery(baseOptions: Apollo.QueryHookOptions<TemplateViewLinkQuery, TemplateViewLinkQueryVariables> & ({ variables: TemplateViewLinkQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<TemplateViewLinkQuery, TemplateViewLinkQueryVariables>(TemplateViewLinkDocument, options);\n      }\nexport function useTemplateViewLinkLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TemplateViewLinkQuery, TemplateViewLinkQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<TemplateViewLinkQuery, TemplateViewLinkQueryVariables>(TemplateViewLinkDocument, options);\n        }\nexport function useTemplateViewLinkSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<TemplateViewLinkQuery, TemplateViewLinkQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<TemplateViewLinkQuery, TemplateViewLinkQueryVariables>(TemplateViewLinkDocument, options);\n        }\nexport type TemplateViewLinkQueryHookResult = ReturnType<typeof useTemplateViewLinkQuery>;\nexport type TemplateViewLinkLazyQueryHookResult = ReturnType<typeof useTemplateViewLinkLazyQuery>;\nexport type TemplateViewLinkSuspenseQueryHookResult = ReturnType<typeof useTemplateViewLinkSuspenseQuery>;\nexport type TemplateViewLinkQueryResult = Apollo.QueryResult<TemplateViewLinkQuery, TemplateViewLinkQueryVariables>;\nexport function refetchTemplateViewLinkQuery(variables: TemplateViewLinkQueryVariables) {\n      return { query: TemplateViewLinkDocument, variables: variables };\n    }\nexport const AvailableTemplateTypesDocument: TypedDocumentNode<AvailableTemplateTypesQuery, AvailableTemplateTypesQueryVariables> = gql`\n  query availableTemplateTypes($countryCode: CleanString!) {\n  availableTemplateTypes(countryCode: $countryCode)\n}\n    `;\n\n/**\n * __useAvailableTemplateTypesQuery__\n *\n * To run a query within a React component, call `useAvailableTemplateTypesQuery` and pass it any options that fit your needs.\n * When your component renders, `useAvailableTemplateTypesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useAvailableTemplateTypesQuery({\n *   variables: {\n *      countryCode: // value for 'countryCode'\n *   },\n * });\n */\nexport function useAvailableTemplateTypesQuery(baseOptions: Apollo.QueryHookOptions<AvailableTemplateTypesQuery, AvailableTemplateTypesQueryVariables> & ({ variables: AvailableTemplateTypesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<AvailableTemplateTypesQuery, AvailableTemplateTypesQueryVariables>(AvailableTemplateTypesDocument, options);\n      }\nexport function useAvailableTemplateTypesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AvailableTemplateTypesQuery, AvailableTemplateTypesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<AvailableTemplateTypesQuery, AvailableTemplateTypesQueryVariables>(AvailableTemplateTypesDocument, options);\n        }\nexport function useAvailableTemplateTypesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AvailableTemplateTypesQuery, AvailableTemplateTypesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<AvailableTemplateTypesQuery, AvailableTemplateTypesQueryVariables>(AvailableTemplateTypesDocument, options);\n        }\nexport type AvailableTemplateTypesQueryHookResult = ReturnType<typeof useAvailableTemplateTypesQuery>;\nexport type AvailableTemplateTypesLazyQueryHookResult = ReturnType<typeof useAvailableTemplateTypesLazyQuery>;\nexport type AvailableTemplateTypesSuspenseQueryHookResult = ReturnType<typeof useAvailableTemplateTypesSuspenseQuery>;\nexport type AvailableTemplateTypesQueryResult = Apollo.QueryResult<AvailableTemplateTypesQuery, AvailableTemplateTypesQueryVariables>;\nexport function refetchAvailableTemplateTypesQuery(variables: AvailableTemplateTypesQueryVariables) {\n      return { query: AvailableTemplateTypesDocument, variables: variables };\n    }\nexport const GetContractLinkDocument: TypedDocumentNode<GetContractLinkQuery, GetContractLinkQueryVariables> = gql`\n  query getContractLink($documentId: DocumentCakeType!) {\n  document(document: $documentId) {\n    id\n    contractLink\n  }\n}\n    `;\n\n/**\n * __useGetContractLinkQuery__\n *\n * To run a query within a React component, call `useGetContractLinkQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetContractLinkQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetContractLinkQuery({\n *   variables: {\n *      documentId: // value for 'documentId'\n *   },\n * });\n */\nexport function useGetContractLinkQuery(baseOptions: Apollo.QueryHookOptions<GetContractLinkQuery, GetContractLinkQueryVariables> & ({ variables: GetContractLinkQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetContractLinkQuery, GetContractLinkQueryVariables>(GetContractLinkDocument, options);\n      }\nexport function useGetContractLinkLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetContractLinkQuery, GetContractLinkQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetContractLinkQuery, GetContractLinkQueryVariables>(GetContractLinkDocument, options);\n        }\nexport function useGetContractLinkSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetContractLinkQuery, GetContractLinkQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetContractLinkQuery, GetContractLinkQueryVariables>(GetContractLinkDocument, options);\n        }\nexport type GetContractLinkQueryHookResult = ReturnType<typeof useGetContractLinkQuery>;\nexport type GetContractLinkLazyQueryHookResult = ReturnType<typeof useGetContractLinkLazyQuery>;\nexport type GetContractLinkSuspenseQueryHookResult = ReturnType<typeof useGetContractLinkSuspenseQuery>;\nexport type GetContractLinkQueryResult = Apollo.QueryResult<GetContractLinkQuery, GetContractLinkQueryVariables>;\nexport function refetchGetContractLinkQuery(variables: GetContractLinkQueryVariables) {\n      return { query: GetContractLinkDocument, variables: variables };\n    }\nexport const GetDocumentMinimalDocument: TypedDocumentNode<GetDocumentMinimalQuery, GetDocumentMinimalQueryVariables> = gql`\n  query getDocumentMinimal($documentId: DocumentCakeType!) {\n  document(document: $documentId) {\n    id\n    name\n    extension\n    contractType\n    signingEnvelopeId\n    signatures {\n      name\n      email\n      status\n    }\n  }\n}\n    `;\n\n/**\n * __useGetDocumentMinimalQuery__\n *\n * To run a query within a React component, call `useGetDocumentMinimalQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDocumentMinimalQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDocumentMinimalQuery({\n *   variables: {\n *      documentId: // value for 'documentId'\n *   },\n * });\n */\nexport function useGetDocumentMinimalQuery(baseOptions: Apollo.QueryHookOptions<GetDocumentMinimalQuery, GetDocumentMinimalQueryVariables> & ({ variables: GetDocumentMinimalQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDocumentMinimalQuery, GetDocumentMinimalQueryVariables>(GetDocumentMinimalDocument, options);\n      }\nexport function useGetDocumentMinimalLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDocumentMinimalQuery, GetDocumentMinimalQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDocumentMinimalQuery, GetDocumentMinimalQueryVariables>(GetDocumentMinimalDocument, options);\n        }\nexport function useGetDocumentMinimalSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDocumentMinimalQuery, GetDocumentMinimalQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDocumentMinimalQuery, GetDocumentMinimalQueryVariables>(GetDocumentMinimalDocument, options);\n        }\nexport type GetDocumentMinimalQueryHookResult = ReturnType<typeof useGetDocumentMinimalQuery>;\nexport type GetDocumentMinimalLazyQueryHookResult = ReturnType<typeof useGetDocumentMinimalLazyQuery>;\nexport type GetDocumentMinimalSuspenseQueryHookResult = ReturnType<typeof useGetDocumentMinimalSuspenseQuery>;\nexport type GetDocumentMinimalQueryResult = Apollo.QueryResult<GetDocumentMinimalQuery, GetDocumentMinimalQueryVariables>;\nexport function refetchGetDocumentMinimalQuery(variables: GetDocumentMinimalQueryVariables) {\n      return { query: GetDocumentMinimalDocument, variables: variables };\n    }\nexport const CreateFolderDocument: TypedDocumentNode<CreateFolderMutation, CreateFolderMutationVariables> = gql`\n  mutation createFolder($organisationId: UUID!, $names: [String]!, $parentId: String, $useExisting: Boolean) {\n  createFolder(\n    organisationId: $organisationId\n    names: $names\n    parentId: $parentId\n    useExisting: $useExisting\n  ) {\n    folders {\n      id\n      name\n    }\n  }\n}\n    `;\nexport type CreateFolderMutationFn = Apollo.MutationFunction<CreateFolderMutation, CreateFolderMutationVariables>;\n\n/**\n * __useCreateFolderMutation__\n *\n * To run a mutation, you first call `useCreateFolderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateFolderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createFolderMutation, { data, loading, error }] = useCreateFolderMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      names: // value for 'names'\n *      parentId: // value for 'parentId'\n *      useExisting: // value for 'useExisting'\n *   },\n * });\n */\nexport function useCreateFolderMutation(baseOptions?: Apollo.MutationHookOptions<CreateFolderMutation, CreateFolderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateFolderMutation, CreateFolderMutationVariables>(CreateFolderDocument, options);\n      }\nexport type CreateFolderMutationHookResult = ReturnType<typeof useCreateFolderMutation>;\nexport type CreateFolderMutationResult = Apollo.MutationResult<CreateFolderMutation>;\nexport type CreateFolderMutationOptions = Apollo.BaseMutationOptions<CreateFolderMutation, CreateFolderMutationVariables>;\nexport const CopyMoveFileOrFolderDocument: TypedDocumentNode<CopyMoveFileOrFolderMutation, CopyMoveFileOrFolderMutationVariables> = gql`\n  mutation copyMoveFileOrFolder($sourceIds: [UUID!]!, $destinationId: UUID, $isMove: Boolean) {\n  copyMoveFileOrFolder(\n    sourceIds: $sourceIds\n    destinationId: $destinationId\n    isMove: $isMove\n  ) {\n    ok\n  }\n}\n    `;\nexport type CopyMoveFileOrFolderMutationFn = Apollo.MutationFunction<CopyMoveFileOrFolderMutation, CopyMoveFileOrFolderMutationVariables>;\n\n/**\n * __useCopyMoveFileOrFolderMutation__\n *\n * To run a mutation, you first call `useCopyMoveFileOrFolderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCopyMoveFileOrFolderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [copyMoveFileOrFolderMutation, { data, loading, error }] = useCopyMoveFileOrFolderMutation({\n *   variables: {\n *      sourceIds: // value for 'sourceIds'\n *      destinationId: // value for 'destinationId'\n *      isMove: // value for 'isMove'\n *   },\n * });\n */\nexport function useCopyMoveFileOrFolderMutation(baseOptions?: Apollo.MutationHookOptions<CopyMoveFileOrFolderMutation, CopyMoveFileOrFolderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CopyMoveFileOrFolderMutation, CopyMoveFileOrFolderMutationVariables>(CopyMoveFileOrFolderDocument, options);\n      }\nexport type CopyMoveFileOrFolderMutationHookResult = ReturnType<typeof useCopyMoveFileOrFolderMutation>;\nexport type CopyMoveFileOrFolderMutationResult = Apollo.MutationResult<CopyMoveFileOrFolderMutation>;\nexport type CopyMoveFileOrFolderMutationOptions = Apollo.BaseMutationOptions<CopyMoveFileOrFolderMutation, CopyMoveFileOrFolderMutationVariables>;\nexport const ShareDocumentDocument: TypedDocumentNode<ShareDocumentMutation, ShareDocumentMutationVariables> = gql`\n  mutation shareDocument($shareholderOrGroupId: UUID!, $documentId: UUID!) {\n  shareDocument(\n    shareholderOrGroupId: $shareholderOrGroupId\n    documentId: $documentId\n  ) {\n    ok\n  }\n}\n    `;\nexport type ShareDocumentMutationFn = Apollo.MutationFunction<ShareDocumentMutation, ShareDocumentMutationVariables>;\n\n/**\n * __useShareDocumentMutation__\n *\n * To run a mutation, you first call `useShareDocumentMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useShareDocumentMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [shareDocumentMutation, { data, loading, error }] = useShareDocumentMutation({\n *   variables: {\n *      shareholderOrGroupId: // value for 'shareholderOrGroupId'\n *      documentId: // value for 'documentId'\n *   },\n * });\n */\nexport function useShareDocumentMutation(baseOptions?: Apollo.MutationHookOptions<ShareDocumentMutation, ShareDocumentMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ShareDocumentMutation, ShareDocumentMutationVariables>(ShareDocumentDocument, options);\n      }\nexport type ShareDocumentMutationHookResult = ReturnType<typeof useShareDocumentMutation>;\nexport type ShareDocumentMutationResult = Apollo.MutationResult<ShareDocumentMutation>;\nexport type ShareDocumentMutationOptions = Apollo.BaseMutationOptions<ShareDocumentMutation, ShareDocumentMutationVariables>;\nexport const RemoveShareDocumentDocument: TypedDocumentNode<RemoveShareDocumentMutation, RemoveShareDocumentMutationVariables> = gql`\n  mutation removeShareDocument($shareholderOrGroupId: UUID!, $documentId: UUID!) {\n  removeShareDocument(\n    shareholderOrGroupId: $shareholderOrGroupId\n    documentId: $documentId\n  ) {\n    ok\n  }\n}\n    `;\nexport type RemoveShareDocumentMutationFn = Apollo.MutationFunction<RemoveShareDocumentMutation, RemoveShareDocumentMutationVariables>;\n\n/**\n * __useRemoveShareDocumentMutation__\n *\n * To run a mutation, you first call `useRemoveShareDocumentMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRemoveShareDocumentMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [removeShareDocumentMutation, { data, loading, error }] = useRemoveShareDocumentMutation({\n *   variables: {\n *      shareholderOrGroupId: // value for 'shareholderOrGroupId'\n *      documentId: // value for 'documentId'\n *   },\n * });\n */\nexport function useRemoveShareDocumentMutation(baseOptions?: Apollo.MutationHookOptions<RemoveShareDocumentMutation, RemoveShareDocumentMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RemoveShareDocumentMutation, RemoveShareDocumentMutationVariables>(RemoveShareDocumentDocument, options);\n      }\nexport type RemoveShareDocumentMutationHookResult = ReturnType<typeof useRemoveShareDocumentMutation>;\nexport type RemoveShareDocumentMutationResult = Apollo.MutationResult<RemoveShareDocumentMutation>;\nexport type RemoveShareDocumentMutationOptions = Apollo.BaseMutationOptions<RemoveShareDocumentMutation, RemoveShareDocumentMutationVariables>;\nexport const DeleteDocumentDocument: TypedDocumentNode<DeleteDocumentMutation, DeleteDocumentMutationVariables> = gql`\n  mutation deleteDocument($documents: [DocumentCakeType!]!) {\n  deleteDocument(documents: $documents) {\n    ok\n  }\n}\n    `;\nexport type DeleteDocumentMutationFn = Apollo.MutationFunction<DeleteDocumentMutation, DeleteDocumentMutationVariables>;\n\n/**\n * __useDeleteDocumentMutation__\n *\n * To run a mutation, you first call `useDeleteDocumentMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteDocumentMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteDocumentMutation, { data, loading, error }] = useDeleteDocumentMutation({\n *   variables: {\n *      documents: // value for 'documents'\n *   },\n * });\n */\nexport function useDeleteDocumentMutation(baseOptions?: Apollo.MutationHookOptions<DeleteDocumentMutation, DeleteDocumentMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteDocumentMutation, DeleteDocumentMutationVariables>(DeleteDocumentDocument, options);\n      }\nexport type DeleteDocumentMutationHookResult = ReturnType<typeof useDeleteDocumentMutation>;\nexport type DeleteDocumentMutationResult = Apollo.MutationResult<DeleteDocumentMutation>;\nexport type DeleteDocumentMutationOptions = Apollo.BaseMutationOptions<DeleteDocumentMutation, DeleteDocumentMutationVariables>;\nexport const RenameDocumentDocument: TypedDocumentNode<RenameDocumentMutation, RenameDocumentMutationVariables> = gql`\n  mutation renameDocument($documentId: UUID!, $newName: String!) {\n  renameDocument(documentId: $documentId, newName: $newName) {\n    ok\n  }\n}\n    `;\nexport type RenameDocumentMutationFn = Apollo.MutationFunction<RenameDocumentMutation, RenameDocumentMutationVariables>;\n\n/**\n * __useRenameDocumentMutation__\n *\n * To run a mutation, you first call `useRenameDocumentMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRenameDocumentMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [renameDocumentMutation, { data, loading, error }] = useRenameDocumentMutation({\n *   variables: {\n *      documentId: // value for 'documentId'\n *      newName: // value for 'newName'\n *   },\n * });\n */\nexport function useRenameDocumentMutation(baseOptions?: Apollo.MutationHookOptions<RenameDocumentMutation, RenameDocumentMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RenameDocumentMutation, RenameDocumentMutationVariables>(RenameDocumentDocument, options);\n      }\nexport type RenameDocumentMutationHookResult = ReturnType<typeof useRenameDocumentMutation>;\nexport type RenameDocumentMutationResult = Apollo.MutationResult<RenameDocumentMutation>;\nexport type RenameDocumentMutationOptions = Apollo.BaseMutationOptions<RenameDocumentMutation, RenameDocumentMutationVariables>;\nexport const GenerateShareCertificatesFromHoldingsDocument: TypedDocumentNode<GenerateShareCertificatesFromHoldingsMutation, GenerateShareCertificatesFromHoldingsMutationVariables> = gql`\n  mutation generateShareCertificatesFromHoldings($shareholderIds: [ShareholderCakeType]!, $certificateNumber: Int!, $selectionOrganisationId: OrganisationCakeType, $selectionSearch: String, $issueDate: Date, $notifyShareholder: Boolean, $disclaimersBySharetype: [SharetypeDisclaimerInputType!]) {\n  generateShareCertificatesFromHoldings(\n    shareholders: $shareholderIds\n    certificateNumber: $certificateNumber\n    organisation: $selectionOrganisationId\n    selectionSearch: $selectionSearch\n    issueDate: $issueDate\n    notifyShareholder: $notifyShareholder\n    disclaimersBySharetype: $disclaimersBySharetype\n  ) {\n    lastCertificateNumber\n  }\n}\n    `;\nexport type GenerateShareCertificatesFromHoldingsMutationFn = Apollo.MutationFunction<GenerateShareCertificatesFromHoldingsMutation, GenerateShareCertificatesFromHoldingsMutationVariables>;\n\n/**\n * __useGenerateShareCertificatesFromHoldingsMutation__\n *\n * To run a mutation, you first call `useGenerateShareCertificatesFromHoldingsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useGenerateShareCertificatesFromHoldingsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [generateShareCertificatesFromHoldingsMutation, { data, loading, error }] = useGenerateShareCertificatesFromHoldingsMutation({\n *   variables: {\n *      shareholderIds: // value for 'shareholderIds'\n *      certificateNumber: // value for 'certificateNumber'\n *      selectionOrganisationId: // value for 'selectionOrganisationId'\n *      selectionSearch: // value for 'selectionSearch'\n *      issueDate: // value for 'issueDate'\n *      notifyShareholder: // value for 'notifyShareholder'\n *      disclaimersBySharetype: // value for 'disclaimersBySharetype'\n *   },\n * });\n */\nexport function useGenerateShareCertificatesFromHoldingsMutation(baseOptions?: Apollo.MutationHookOptions<GenerateShareCertificatesFromHoldingsMutation, GenerateShareCertificatesFromHoldingsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<GenerateShareCertificatesFromHoldingsMutation, GenerateShareCertificatesFromHoldingsMutationVariables>(GenerateShareCertificatesFromHoldingsDocument, options);\n      }\nexport type GenerateShareCertificatesFromHoldingsMutationHookResult = ReturnType<typeof useGenerateShareCertificatesFromHoldingsMutation>;\nexport type GenerateShareCertificatesFromHoldingsMutationResult = Apollo.MutationResult<GenerateShareCertificatesFromHoldingsMutation>;\nexport type GenerateShareCertificatesFromHoldingsMutationOptions = Apollo.BaseMutationOptions<GenerateShareCertificatesFromHoldingsMutation, GenerateShareCertificatesFromHoldingsMutationVariables>;\nexport const GenerateShareCertificateByCriteriaDocument: TypedDocumentNode<GenerateShareCertificateByCriteriaMutation, GenerateShareCertificateByCriteriaMutationVariables> = gql`\n  mutation generateShareCertificateByCriteria($organisationId: OrganisationCakeType!, $certificateNumber: Int!, $filterDate: Date, $filterDateIsGte: Boolean, $filterShareType: SharetypeCakeType, $issueDate: Date, $notifyShareholder: Boolean) {\n  generateShareCertificateByCriteria(\n    organisation: $organisationId\n    certificateNumber: $certificateNumber\n    filterDate: $filterDate\n    filterDateIsGte: $filterDateIsGte\n    filterShareType: $filterShareType\n    certificateIssueDate: $issueDate\n    notifyShareholder: $notifyShareholder\n  )\n}\n    `;\nexport type GenerateShareCertificateByCriteriaMutationFn = Apollo.MutationFunction<GenerateShareCertificateByCriteriaMutation, GenerateShareCertificateByCriteriaMutationVariables>;\n\n/**\n * __useGenerateShareCertificateByCriteriaMutation__\n *\n * To run a mutation, you first call `useGenerateShareCertificateByCriteriaMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useGenerateShareCertificateByCriteriaMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [generateShareCertificateByCriteriaMutation, { data, loading, error }] = useGenerateShareCertificateByCriteriaMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      certificateNumber: // value for 'certificateNumber'\n *      filterDate: // value for 'filterDate'\n *      filterDateIsGte: // value for 'filterDateIsGte'\n *      filterShareType: // value for 'filterShareType'\n *      issueDate: // value for 'issueDate'\n *      notifyShareholder: // value for 'notifyShareholder'\n *   },\n * });\n */\nexport function useGenerateShareCertificateByCriteriaMutation(baseOptions?: Apollo.MutationHookOptions<GenerateShareCertificateByCriteriaMutation, GenerateShareCertificateByCriteriaMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<GenerateShareCertificateByCriteriaMutation, GenerateShareCertificateByCriteriaMutationVariables>(GenerateShareCertificateByCriteriaDocument, options);\n      }\nexport type GenerateShareCertificateByCriteriaMutationHookResult = ReturnType<typeof useGenerateShareCertificateByCriteriaMutation>;\nexport type GenerateShareCertificateByCriteriaMutationResult = Apollo.MutationResult<GenerateShareCertificateByCriteriaMutation>;\nexport type GenerateShareCertificateByCriteriaMutationOptions = Apollo.BaseMutationOptions<GenerateShareCertificateByCriteriaMutation, GenerateShareCertificateByCriteriaMutationVariables>;\nexport const FinaliseTemplateDocument: TypedDocumentNode<FinaliseTemplateMutation, FinaliseTemplateMutationVariables> = gql`\n  mutation finaliseTemplate($document: DocumentCakeType!, $revert: Boolean) {\n  finaliseTemplate(document: $document, revert: $revert) {\n    ok\n  }\n}\n    `;\nexport type FinaliseTemplateMutationFn = Apollo.MutationFunction<FinaliseTemplateMutation, FinaliseTemplateMutationVariables>;\n\n/**\n * __useFinaliseTemplateMutation__\n *\n * To run a mutation, you first call `useFinaliseTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useFinaliseTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [finaliseTemplateMutation, { data, loading, error }] = useFinaliseTemplateMutation({\n *   variables: {\n *      document: // value for 'document'\n *      revert: // value for 'revert'\n *   },\n * });\n */\nexport function useFinaliseTemplateMutation(baseOptions?: Apollo.MutationHookOptions<FinaliseTemplateMutation, FinaliseTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<FinaliseTemplateMutation, FinaliseTemplateMutationVariables>(FinaliseTemplateDocument, options);\n      }\nexport type FinaliseTemplateMutationHookResult = ReturnType<typeof useFinaliseTemplateMutation>;\nexport type FinaliseTemplateMutationResult = Apollo.MutationResult<FinaliseTemplateMutation>;\nexport type FinaliseTemplateMutationOptions = Apollo.BaseMutationOptions<FinaliseTemplateMutation, FinaliseTemplateMutationVariables>;\nexport const MoveFromSigningToDocumentsDocument: TypedDocumentNode<MoveFromSigningToDocumentsMutation, MoveFromSigningToDocumentsMutationVariables> = gql`\n  mutation moveFromSigningToDocuments($documentId: UUID!, $folder: String!) {\n  moveFromSigningToDocuments(documentId: $documentId, folder: $folder) {\n    ok\n  }\n}\n    `;\nexport type MoveFromSigningToDocumentsMutationFn = Apollo.MutationFunction<MoveFromSigningToDocumentsMutation, MoveFromSigningToDocumentsMutationVariables>;\n\n/**\n * __useMoveFromSigningToDocumentsMutation__\n *\n * To run a mutation, you first call `useMoveFromSigningToDocumentsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useMoveFromSigningToDocumentsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [moveFromSigningToDocumentsMutation, { data, loading, error }] = useMoveFromSigningToDocumentsMutation({\n *   variables: {\n *      documentId: // value for 'documentId'\n *      folder: // value for 'folder'\n *   },\n * });\n */\nexport function useMoveFromSigningToDocumentsMutation(baseOptions?: Apollo.MutationHookOptions<MoveFromSigningToDocumentsMutation, MoveFromSigningToDocumentsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<MoveFromSigningToDocumentsMutation, MoveFromSigningToDocumentsMutationVariables>(MoveFromSigningToDocumentsDocument, options);\n      }\nexport type MoveFromSigningToDocumentsMutationHookResult = ReturnType<typeof useMoveFromSigningToDocumentsMutation>;\nexport type MoveFromSigningToDocumentsMutationResult = Apollo.MutationResult<MoveFromSigningToDocumentsMutation>;\nexport type MoveFromSigningToDocumentsMutationOptions = Apollo.BaseMutationOptions<MoveFromSigningToDocumentsMutation, MoveFromSigningToDocumentsMutationVariables>;\nexport const StartContractSigningDocument: TypedDocumentNode<StartContractSigningMutation, StartContractSigningMutationVariables> = gql`\n  mutation startContractSigning($document: DocumentCakeType!, $emailSubject: CleanString!, $emailBody: CleanString!, $shareholderSigners: [ShareholderCakeType!], $officeholderSigners: [OfficeholderCakeType!], $userSigners: [UserCakeType!], $groupSigners: [CakeGroupCakeType!]) {\n  startContractSigning(\n    document: $document\n    shareholderSigners: $shareholderSigners\n    officeholderSigners: $officeholderSigners\n    userSigners: $userSigners\n    groupSigners: $groupSigners\n    emailSubject: $emailSubject\n    emailBody: $emailBody\n  ) {\n    ok\n  }\n}\n    `;\nexport type StartContractSigningMutationFn = Apollo.MutationFunction<StartContractSigningMutation, StartContractSigningMutationVariables>;\n\n/**\n * __useStartContractSigningMutation__\n *\n * To run a mutation, you first call `useStartContractSigningMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useStartContractSigningMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [startContractSigningMutation, { data, loading, error }] = useStartContractSigningMutation({\n *   variables: {\n *      document: // value for 'document'\n *      emailSubject: // value for 'emailSubject'\n *      emailBody: // value for 'emailBody'\n *      shareholderSigners: // value for 'shareholderSigners'\n *      officeholderSigners: // value for 'officeholderSigners'\n *      userSigners: // value for 'userSigners'\n *      groupSigners: // value for 'groupSigners'\n *   },\n * });\n */\nexport function useStartContractSigningMutation(baseOptions?: Apollo.MutationHookOptions<StartContractSigningMutation, StartContractSigningMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<StartContractSigningMutation, StartContractSigningMutationVariables>(StartContractSigningDocument, options);\n      }\nexport type StartContractSigningMutationHookResult = ReturnType<typeof useStartContractSigningMutation>;\nexport type StartContractSigningMutationResult = Apollo.MutationResult<StartContractSigningMutation>;\nexport type StartContractSigningMutationOptions = Apollo.BaseMutationOptions<StartContractSigningMutation, StartContractSigningMutationVariables>;\nexport const CreateDraftContractDocument: TypedDocumentNode<CreateDraftContractMutation, CreateDraftContractMutationVariables> = gql`\n  mutation createDraftContract($organisationId: OrganisationCakeType!, $contractType: String!, $documentName: String!) {\n  createDraftContract(\n    organisation: $organisationId\n    contractType: $contractType\n    documentName: $documentName\n  ) {\n    ok\n  }\n}\n    `;\nexport type CreateDraftContractMutationFn = Apollo.MutationFunction<CreateDraftContractMutation, CreateDraftContractMutationVariables>;\n\n/**\n * __useCreateDraftContractMutation__\n *\n * To run a mutation, you first call `useCreateDraftContractMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateDraftContractMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createDraftContractMutation, { data, loading, error }] = useCreateDraftContractMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      contractType: // value for 'contractType'\n *      documentName: // value for 'documentName'\n *   },\n * });\n */\nexport function useCreateDraftContractMutation(baseOptions?: Apollo.MutationHookOptions<CreateDraftContractMutation, CreateDraftContractMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateDraftContractMutation, CreateDraftContractMutationVariables>(CreateDraftContractDocument, options);\n      }\nexport type CreateDraftContractMutationHookResult = ReturnType<typeof useCreateDraftContractMutation>;\nexport type CreateDraftContractMutationResult = Apollo.MutationResult<CreateDraftContractMutation>;\nexport type CreateDraftContractMutationOptions = Apollo.BaseMutationOptions<CreateDraftContractMutation, CreateDraftContractMutationVariables>;\nexport const FixContractTemplatePlaceholdersDocument: TypedDocumentNode<FixContractTemplatePlaceholdersMutation, FixContractTemplatePlaceholdersMutationVariables> = gql`\n  mutation fixContractTemplatePlaceholders($document: DocumentCakeType!) {\n  fixContractTemplatePlaceholders(document: $document)\n}\n    `;\nexport type FixContractTemplatePlaceholdersMutationFn = Apollo.MutationFunction<FixContractTemplatePlaceholdersMutation, FixContractTemplatePlaceholdersMutationVariables>;\n\n/**\n * __useFixContractTemplatePlaceholdersMutation__\n *\n * To run a mutation, you first call `useFixContractTemplatePlaceholdersMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useFixContractTemplatePlaceholdersMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [fixContractTemplatePlaceholdersMutation, { data, loading, error }] = useFixContractTemplatePlaceholdersMutation({\n *   variables: {\n *      document: // value for 'document'\n *   },\n * });\n */\nexport function useFixContractTemplatePlaceholdersMutation(baseOptions?: Apollo.MutationHookOptions<FixContractTemplatePlaceholdersMutation, FixContractTemplatePlaceholdersMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<FixContractTemplatePlaceholdersMutation, FixContractTemplatePlaceholdersMutationVariables>(FixContractTemplatePlaceholdersDocument, options);\n      }\nexport type FixContractTemplatePlaceholdersMutationHookResult = ReturnType<typeof useFixContractTemplatePlaceholdersMutation>;\nexport type FixContractTemplatePlaceholdersMutationResult = Apollo.MutationResult<FixContractTemplatePlaceholdersMutation>;\nexport type FixContractTemplatePlaceholdersMutationOptions = Apollo.BaseMutationOptions<FixContractTemplatePlaceholdersMutation, FixContractTemplatePlaceholdersMutationVariables>;\nexport const SyncWithMasterTemplateDocument: TypedDocumentNode<SyncWithMasterTemplateMutation, SyncWithMasterTemplateMutationVariables> = gql`\n  mutation syncWithMasterTemplate($document: DocumentCakeType!) {\n  syncWithMasterTemplate(document: $document)\n}\n    `;\nexport type SyncWithMasterTemplateMutationFn = Apollo.MutationFunction<SyncWithMasterTemplateMutation, SyncWithMasterTemplateMutationVariables>;\n\n/**\n * __useSyncWithMasterTemplateMutation__\n *\n * To run a mutation, you first call `useSyncWithMasterTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSyncWithMasterTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [syncWithMasterTemplateMutation, { data, loading, error }] = useSyncWithMasterTemplateMutation({\n *   variables: {\n *      document: // value for 'document'\n *   },\n * });\n */\nexport function useSyncWithMasterTemplateMutation(baseOptions?: Apollo.MutationHookOptions<SyncWithMasterTemplateMutation, SyncWithMasterTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SyncWithMasterTemplateMutation, SyncWithMasterTemplateMutationVariables>(SyncWithMasterTemplateDocument, options);\n      }\nexport type SyncWithMasterTemplateMutationHookResult = ReturnType<typeof useSyncWithMasterTemplateMutation>;\nexport type SyncWithMasterTemplateMutationResult = Apollo.MutationResult<SyncWithMasterTemplateMutation>;\nexport type SyncWithMasterTemplateMutationOptions = Apollo.BaseMutationOptions<SyncWithMasterTemplateMutation, SyncWithMasterTemplateMutationVariables>;\nexport const GenerateTransactionalShareCertificateDocument: TypedDocumentNode<GenerateTransactionalShareCertificateMutation, GenerateTransactionalShareCertificateMutationVariables> = gql`\n  mutation generateTransactionalShareCertificate($transactionId: ShareholdingTransactionCakeType!, $certificateNumber: PositiveInteger!, $issueDate: Date, $disclaimerBySharetype: SharetypeDisclaimerInputType) {\n  generateTransactionalShareCertificate(\n    transaction: $transactionId\n    certificateNumber: $certificateNumber\n    issueDate: $issueDate\n    disclaimerBySharetype: $disclaimerBySharetype\n  )\n}\n    `;\nexport type GenerateTransactionalShareCertificateMutationFn = Apollo.MutationFunction<GenerateTransactionalShareCertificateMutation, GenerateTransactionalShareCertificateMutationVariables>;\n\n/**\n * __useGenerateTransactionalShareCertificateMutation__\n *\n * To run a mutation, you first call `useGenerateTransactionalShareCertificateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useGenerateTransactionalShareCertificateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [generateTransactionalShareCertificateMutation, { data, loading, error }] = useGenerateTransactionalShareCertificateMutation({\n *   variables: {\n *      transactionId: // value for 'transactionId'\n *      certificateNumber: // value for 'certificateNumber'\n *      issueDate: // value for 'issueDate'\n *      disclaimerBySharetype: // value for 'disclaimerBySharetype'\n *   },\n * });\n */\nexport function useGenerateTransactionalShareCertificateMutation(baseOptions?: Apollo.MutationHookOptions<GenerateTransactionalShareCertificateMutation, GenerateTransactionalShareCertificateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<GenerateTransactionalShareCertificateMutation, GenerateTransactionalShareCertificateMutationVariables>(GenerateTransactionalShareCertificateDocument, options);\n      }\nexport type GenerateTransactionalShareCertificateMutationHookResult = ReturnType<typeof useGenerateTransactionalShareCertificateMutation>;\nexport type GenerateTransactionalShareCertificateMutationResult = Apollo.MutationResult<GenerateTransactionalShareCertificateMutation>;\nexport type GenerateTransactionalShareCertificateMutationOptions = Apollo.BaseMutationOptions<GenerateTransactionalShareCertificateMutation, GenerateTransactionalShareCertificateMutationVariables>;\nexport const UploadToScanbotDocument: TypedDocumentNode<UploadToScanbotMutation, UploadToScanbotMutationVariables> = gql`\n  mutation uploadToScanbot($document: DocumentCakeType!) {\n  uploadToScanbot(document: $document) {\n    id\n  }\n}\n    `;\nexport type UploadToScanbotMutationFn = Apollo.MutationFunction<UploadToScanbotMutation, UploadToScanbotMutationVariables>;\n\n/**\n * __useUploadToScanbotMutation__\n *\n * To run a mutation, you first call `useUploadToScanbotMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUploadToScanbotMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [uploadToScanbotMutation, { data, loading, error }] = useUploadToScanbotMutation({\n *   variables: {\n *      document: // value for 'document'\n *   },\n * });\n */\nexport function useUploadToScanbotMutation(baseOptions?: Apollo.MutationHookOptions<UploadToScanbotMutation, UploadToScanbotMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UploadToScanbotMutation, UploadToScanbotMutationVariables>(UploadToScanbotDocument, options);\n      }\nexport type UploadToScanbotMutationHookResult = ReturnType<typeof useUploadToScanbotMutation>;\nexport type UploadToScanbotMutationResult = Apollo.MutationResult<UploadToScanbotMutation>;\nexport type UploadToScanbotMutationOptions = Apollo.BaseMutationOptions<UploadToScanbotMutation, UploadToScanbotMutationVariables>;\nexport const GetTemplatesByContractTypeDocument: TypedDocumentNode<GetTemplatesByContractTypeQuery, GetTemplatesByContractTypeQueryVariables> = gql`\n  query getTemplatesByContractType($organisation: OrganisationCakeType!, $country: CleanString, $contractTypes: [CleanString!]!) {\n  templatesByContractType(\n    organisation: $organisation\n    contractTypes: $contractTypes\n    country: $country\n  ) {\n    id\n    name\n    contractLink\n    contractProvider\n    contractType\n    created\n    updated: modified\n  }\n}\n    `;\n\n/**\n * __useGetTemplatesByContractTypeQuery__\n *\n * To run a query within a React component, call `useGetTemplatesByContractTypeQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetTemplatesByContractTypeQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetTemplatesByContractTypeQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      country: // value for 'country'\n *      contractTypes: // value for 'contractTypes'\n *   },\n * });\n */\nexport function useGetTemplatesByContractTypeQuery(baseOptions: Apollo.QueryHookOptions<GetTemplatesByContractTypeQuery, GetTemplatesByContractTypeQueryVariables> & ({ variables: GetTemplatesByContractTypeQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetTemplatesByContractTypeQuery, GetTemplatesByContractTypeQueryVariables>(GetTemplatesByContractTypeDocument, options);\n      }\nexport function useGetTemplatesByContractTypeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetTemplatesByContractTypeQuery, GetTemplatesByContractTypeQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetTemplatesByContractTypeQuery, GetTemplatesByContractTypeQueryVariables>(GetTemplatesByContractTypeDocument, options);\n        }\nexport function useGetTemplatesByContractTypeSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetTemplatesByContractTypeQuery, GetTemplatesByContractTypeQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetTemplatesByContractTypeQuery, GetTemplatesByContractTypeQueryVariables>(GetTemplatesByContractTypeDocument, options);\n        }\nexport type GetTemplatesByContractTypeQueryHookResult = ReturnType<typeof useGetTemplatesByContractTypeQuery>;\nexport type GetTemplatesByContractTypeLazyQueryHookResult = ReturnType<typeof useGetTemplatesByContractTypeLazyQuery>;\nexport type GetTemplatesByContractTypeSuspenseQueryHookResult = ReturnType<typeof useGetTemplatesByContractTypeSuspenseQuery>;\nexport type GetTemplatesByContractTypeQueryResult = Apollo.QueryResult<GetTemplatesByContractTypeQuery, GetTemplatesByContractTypeQueryVariables>;\nexport function refetchGetTemplatesByContractTypeQuery(variables: GetTemplatesByContractTypeQueryVariables) {\n      return { query: GetTemplatesByContractTypeDocument, variables: variables };\n    }\nexport const GetPlanToEditEsopDocument: TypedDocumentNode<GetPlanToEditEsopQuery, GetPlanToEditEsopQueryVariables> = gql`\n  query getPlanToEditESOP($organisationId: UUID!, $planId: UUID!) {\n  plan: esops(organisationId: $organisationId, filterPlan: $planId) {\n    id\n    name\n    vestingValue\n    optionPrice\n    requireWitness\n    totalVested\n    totalExercised\n    totalOffered\n    organisation {\n      id\n      fullyDilutedShares\n      country\n      currency\n      valuationAt {\n        valuation\n      }\n    }\n    group: offerGroup {\n      id\n      country\n      exercisePrice\n      restrictionsOnShares\n      allowNomineeTrust\n      requireBoardApproval\n      disclosurePeriodDays\n      isEditable\n      currency\n      optionPrice\n      exercisePrice\n      groupCurrency\n      allowEarlyExercise\n      sendExpirationNotification\n      autoLapseOnExpirationDate\n      exerciseExpirationStartingPoint\n      exerciseExpireTime {\n        quantity\n        unit\n      }\n      sharetype {\n        id\n        name\n        symbol\n      }\n      ptepSettings {\n        ptepInterval {\n          quantity\n          unit\n        }\n      }\n    }\n  }\n  sharetypes(organisationId: $organisationId) {\n    id\n    name\n    symbol\n  }\n}\n    `;\n\n/**\n * __useGetPlanToEditEsopQuery__\n *\n * To run a query within a React component, call `useGetPlanToEditEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanToEditEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanToEditEsopQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      planId: // value for 'planId'\n *   },\n * });\n */\nexport function useGetPlanToEditEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlanToEditEsopQuery, GetPlanToEditEsopQueryVariables> & ({ variables: GetPlanToEditEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanToEditEsopQuery, GetPlanToEditEsopQueryVariables>(GetPlanToEditEsopDocument, options);\n      }\nexport function useGetPlanToEditEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanToEditEsopQuery, GetPlanToEditEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanToEditEsopQuery, GetPlanToEditEsopQueryVariables>(GetPlanToEditEsopDocument, options);\n        }\nexport function useGetPlanToEditEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanToEditEsopQuery, GetPlanToEditEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanToEditEsopQuery, GetPlanToEditEsopQueryVariables>(GetPlanToEditEsopDocument, options);\n        }\nexport type GetPlanToEditEsopQueryHookResult = ReturnType<typeof useGetPlanToEditEsopQuery>;\nexport type GetPlanToEditEsopLazyQueryHookResult = ReturnType<typeof useGetPlanToEditEsopLazyQuery>;\nexport type GetPlanToEditEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlanToEditEsopSuspenseQuery>;\nexport type GetPlanToEditEsopQueryResult = Apollo.QueryResult<GetPlanToEditEsopQuery, GetPlanToEditEsopQueryVariables>;\nexport function refetchGetPlanToEditEsopQuery(variables: GetPlanToEditEsopQueryVariables) {\n      return { query: GetPlanToEditEsopDocument, variables: variables };\n    }\nexport const GetPlanOfferToEditOptionPriceEsopDocument: TypedDocumentNode<GetPlanOfferToEditOptionPriceEsopQuery, GetPlanOfferToEditOptionPriceEsopQueryVariables> = gql`\n  query getPlanOfferToEditOptionPriceESOP($offerId: UUID!, $plan: EsopCakeType!, $offerGroup: EsopOfferGroupCakeType) {\n  offer: esopOffer(offerId: $offerId) {\n    id\n    created\n    modified\n    currency\n    country\n    plan {\n      group: offerGroup {\n        optionPrice\n      }\n    }\n    optionPrice\n  }\n  checkOffersEditability: offersPostGrantOptionPriceEditabilityEsop(\n    page: 1\n    itemsPerPage: 1\n    offerIds: [$offerId]\n    plan: $plan\n    offerGroup: $offerGroup\n  ) {\n    pageData {\n      offerId\n      canEdit\n      reasons\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOfferToEditOptionPriceEsopQuery__\n *\n * To run a query within a React component, call `useGetPlanOfferToEditOptionPriceEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOfferToEditOptionPriceEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOfferToEditOptionPriceEsopQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      plan: // value for 'plan'\n *      offerGroup: // value for 'offerGroup'\n *   },\n * });\n */\nexport function useGetPlanOfferToEditOptionPriceEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOfferToEditOptionPriceEsopQuery, GetPlanOfferToEditOptionPriceEsopQueryVariables> & ({ variables: GetPlanOfferToEditOptionPriceEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOfferToEditOptionPriceEsopQuery, GetPlanOfferToEditOptionPriceEsopQueryVariables>(GetPlanOfferToEditOptionPriceEsopDocument, options);\n      }\nexport function useGetPlanOfferToEditOptionPriceEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOfferToEditOptionPriceEsopQuery, GetPlanOfferToEditOptionPriceEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOfferToEditOptionPriceEsopQuery, GetPlanOfferToEditOptionPriceEsopQueryVariables>(GetPlanOfferToEditOptionPriceEsopDocument, options);\n        }\nexport function useGetPlanOfferToEditOptionPriceEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOfferToEditOptionPriceEsopQuery, GetPlanOfferToEditOptionPriceEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOfferToEditOptionPriceEsopQuery, GetPlanOfferToEditOptionPriceEsopQueryVariables>(GetPlanOfferToEditOptionPriceEsopDocument, options);\n        }\nexport type GetPlanOfferToEditOptionPriceEsopQueryHookResult = ReturnType<typeof useGetPlanOfferToEditOptionPriceEsopQuery>;\nexport type GetPlanOfferToEditOptionPriceEsopLazyQueryHookResult = ReturnType<typeof useGetPlanOfferToEditOptionPriceEsopLazyQuery>;\nexport type GetPlanOfferToEditOptionPriceEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlanOfferToEditOptionPriceEsopSuspenseQuery>;\nexport type GetPlanOfferToEditOptionPriceEsopQueryResult = Apollo.QueryResult<GetPlanOfferToEditOptionPriceEsopQuery, GetPlanOfferToEditOptionPriceEsopQueryVariables>;\nexport function refetchGetPlanOfferToEditOptionPriceEsopQuery(variables: GetPlanOfferToEditOptionPriceEsopQueryVariables) {\n      return { query: GetPlanOfferToEditOptionPriceEsopDocument, variables: variables };\n    }\nexport const GetPlanOfferToEditExercisePriceEsopDocument: TypedDocumentNode<GetPlanOfferToEditExercisePriceEsopQuery, GetPlanOfferToEditExercisePriceEsopQueryVariables> = gql`\n  query getPlanOfferToEditExercisePriceESOP($offerId: UUID!, $plan: EsopCakeType!, $offerGroup: EsopOfferGroupCakeType) {\n  offer: esopOffer(offerId: $offerId) {\n    id\n    created\n    modified\n    currency\n    country\n    plan {\n      group: offerGroup {\n        exercisePrice\n      }\n    }\n    exercisePrice\n  }\n  checkOffersEditability: offersPostGrantExercisePriceEditabilityEsop(\n    page: 1\n    itemsPerPage: 1\n    offerIds: [$offerId]\n    plan: $plan\n    offerGroup: $offerGroup\n  ) {\n    pageData {\n      offerId\n      canEdit\n      reasons\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOfferToEditExercisePriceEsopQuery__\n *\n * To run a query within a React component, call `useGetPlanOfferToEditExercisePriceEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOfferToEditExercisePriceEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOfferToEditExercisePriceEsopQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      plan: // value for 'plan'\n *      offerGroup: // value for 'offerGroup'\n *   },\n * });\n */\nexport function useGetPlanOfferToEditExercisePriceEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOfferToEditExercisePriceEsopQuery, GetPlanOfferToEditExercisePriceEsopQueryVariables> & ({ variables: GetPlanOfferToEditExercisePriceEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOfferToEditExercisePriceEsopQuery, GetPlanOfferToEditExercisePriceEsopQueryVariables>(GetPlanOfferToEditExercisePriceEsopDocument, options);\n      }\nexport function useGetPlanOfferToEditExercisePriceEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOfferToEditExercisePriceEsopQuery, GetPlanOfferToEditExercisePriceEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOfferToEditExercisePriceEsopQuery, GetPlanOfferToEditExercisePriceEsopQueryVariables>(GetPlanOfferToEditExercisePriceEsopDocument, options);\n        }\nexport function useGetPlanOfferToEditExercisePriceEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOfferToEditExercisePriceEsopQuery, GetPlanOfferToEditExercisePriceEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOfferToEditExercisePriceEsopQuery, GetPlanOfferToEditExercisePriceEsopQueryVariables>(GetPlanOfferToEditExercisePriceEsopDocument, options);\n        }\nexport type GetPlanOfferToEditExercisePriceEsopQueryHookResult = ReturnType<typeof useGetPlanOfferToEditExercisePriceEsopQuery>;\nexport type GetPlanOfferToEditExercisePriceEsopLazyQueryHookResult = ReturnType<typeof useGetPlanOfferToEditExercisePriceEsopLazyQuery>;\nexport type GetPlanOfferToEditExercisePriceEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlanOfferToEditExercisePriceEsopSuspenseQuery>;\nexport type GetPlanOfferToEditExercisePriceEsopQueryResult = Apollo.QueryResult<GetPlanOfferToEditExercisePriceEsopQuery, GetPlanOfferToEditExercisePriceEsopQueryVariables>;\nexport function refetchGetPlanOfferToEditExercisePriceEsopQuery(variables: GetPlanOfferToEditExercisePriceEsopQueryVariables) {\n      return { query: GetPlanOfferToEditExercisePriceEsopDocument, variables: variables };\n    }\nexport const GetPlanOfferToEditGrantDateEsopDocument: TypedDocumentNode<GetPlanOfferToEditGrantDateEsopQuery, GetPlanOfferToEditGrantDateEsopQueryVariables> = gql`\n  query getPlanOfferToEditGrantDateESOP($offerId: UUID!, $plan: EsopCakeType!, $offerGroup: EsopOfferGroupCakeType) {\n  offer: esopOffer(offerId: $offerId) {\n    id\n    created\n    modified\n    grantDateDefault\n    dateGranted\n  }\n  checkOffersEditability: offersPostGrantGrantDateEditabilityEsop(\n    page: 1\n    itemsPerPage: 1\n    offerIds: [$offerId]\n    plan: $plan\n    offerGroup: $offerGroup\n  ) {\n    pageData {\n      offerId\n      canEdit\n      reasons\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOfferToEditGrantDateEsopQuery__\n *\n * To run a query within a React component, call `useGetPlanOfferToEditGrantDateEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOfferToEditGrantDateEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOfferToEditGrantDateEsopQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      plan: // value for 'plan'\n *      offerGroup: // value for 'offerGroup'\n *   },\n * });\n */\nexport function useGetPlanOfferToEditGrantDateEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOfferToEditGrantDateEsopQuery, GetPlanOfferToEditGrantDateEsopQueryVariables> & ({ variables: GetPlanOfferToEditGrantDateEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOfferToEditGrantDateEsopQuery, GetPlanOfferToEditGrantDateEsopQueryVariables>(GetPlanOfferToEditGrantDateEsopDocument, options);\n      }\nexport function useGetPlanOfferToEditGrantDateEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOfferToEditGrantDateEsopQuery, GetPlanOfferToEditGrantDateEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOfferToEditGrantDateEsopQuery, GetPlanOfferToEditGrantDateEsopQueryVariables>(GetPlanOfferToEditGrantDateEsopDocument, options);\n        }\nexport function useGetPlanOfferToEditGrantDateEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOfferToEditGrantDateEsopQuery, GetPlanOfferToEditGrantDateEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOfferToEditGrantDateEsopQuery, GetPlanOfferToEditGrantDateEsopQueryVariables>(GetPlanOfferToEditGrantDateEsopDocument, options);\n        }\nexport type GetPlanOfferToEditGrantDateEsopQueryHookResult = ReturnType<typeof useGetPlanOfferToEditGrantDateEsopQuery>;\nexport type GetPlanOfferToEditGrantDateEsopLazyQueryHookResult = ReturnType<typeof useGetPlanOfferToEditGrantDateEsopLazyQuery>;\nexport type GetPlanOfferToEditGrantDateEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlanOfferToEditGrantDateEsopSuspenseQuery>;\nexport type GetPlanOfferToEditGrantDateEsopQueryResult = Apollo.QueryResult<GetPlanOfferToEditGrantDateEsopQuery, GetPlanOfferToEditGrantDateEsopQueryVariables>;\nexport function refetchGetPlanOfferToEditGrantDateEsopQuery(variables: GetPlanOfferToEditGrantDateEsopQueryVariables) {\n      return { query: GetPlanOfferToEditGrantDateEsopDocument, variables: variables };\n    }\nexport const GetPlanOfferToEditExpireDateEsopDocument: TypedDocumentNode<GetPlanOfferToEditExpireDateEsopQuery, GetPlanOfferToEditExpireDateEsopQueryVariables> = gql`\n  query getPlanOfferToEditExpireDateESOP($offerId: UUID!) {\n  offer: esopOffer(offerId: $offerId) {\n    id\n    created\n    modified\n    exerciseExpireDate\n    exerciseExpirationStartingPoint\n    exerciseExpireTime {\n      quantity\n      unit\n    }\n    sendExpirationNotification\n    autoLapseOnExpirationDate\n  }\n}\n    `;\n\n/**\n * __useGetPlanOfferToEditExpireDateEsopQuery__\n *\n * To run a query within a React component, call `useGetPlanOfferToEditExpireDateEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOfferToEditExpireDateEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOfferToEditExpireDateEsopQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useGetPlanOfferToEditExpireDateEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOfferToEditExpireDateEsopQuery, GetPlanOfferToEditExpireDateEsopQueryVariables> & ({ variables: GetPlanOfferToEditExpireDateEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOfferToEditExpireDateEsopQuery, GetPlanOfferToEditExpireDateEsopQueryVariables>(GetPlanOfferToEditExpireDateEsopDocument, options);\n      }\nexport function useGetPlanOfferToEditExpireDateEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOfferToEditExpireDateEsopQuery, GetPlanOfferToEditExpireDateEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOfferToEditExpireDateEsopQuery, GetPlanOfferToEditExpireDateEsopQueryVariables>(GetPlanOfferToEditExpireDateEsopDocument, options);\n        }\nexport function useGetPlanOfferToEditExpireDateEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOfferToEditExpireDateEsopQuery, GetPlanOfferToEditExpireDateEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOfferToEditExpireDateEsopQuery, GetPlanOfferToEditExpireDateEsopQueryVariables>(GetPlanOfferToEditExpireDateEsopDocument, options);\n        }\nexport type GetPlanOfferToEditExpireDateEsopQueryHookResult = ReturnType<typeof useGetPlanOfferToEditExpireDateEsopQuery>;\nexport type GetPlanOfferToEditExpireDateEsopLazyQueryHookResult = ReturnType<typeof useGetPlanOfferToEditExpireDateEsopLazyQuery>;\nexport type GetPlanOfferToEditExpireDateEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlanOfferToEditExpireDateEsopSuspenseQuery>;\nexport type GetPlanOfferToEditExpireDateEsopQueryResult = Apollo.QueryResult<GetPlanOfferToEditExpireDateEsopQuery, GetPlanOfferToEditExpireDateEsopQueryVariables>;\nexport function refetchGetPlanOfferToEditExpireDateEsopQuery(variables: GetPlanOfferToEditExpireDateEsopQueryVariables) {\n      return { query: GetPlanOfferToEditExpireDateEsopDocument, variables: variables };\n    }\nexport const GetPlanOfferToEditVestingEventsEsopDocument: TypedDocumentNode<GetPlanOfferToEditVestingEventsEsopQuery, GetPlanOfferToEditVestingEventsEsopQueryVariables> = gql`\n  query getPlanOfferToEditVestingEventsESOP($offerId: UUID!) {\n  offer: esopOffer(offerId: $offerId) {\n    id\n    created\n    modified\n    vestStartDate\n    group {\n      plan {\n        organisation {\n          type\n        }\n      }\n    }\n    vestingEvents {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: esoptransactionSet {\n        id\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOfferToEditVestingEventsEsopQuery__\n *\n * To run a query within a React component, call `useGetPlanOfferToEditVestingEventsEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOfferToEditVestingEventsEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOfferToEditVestingEventsEsopQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useGetPlanOfferToEditVestingEventsEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOfferToEditVestingEventsEsopQuery, GetPlanOfferToEditVestingEventsEsopQueryVariables> & ({ variables: GetPlanOfferToEditVestingEventsEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOfferToEditVestingEventsEsopQuery, GetPlanOfferToEditVestingEventsEsopQueryVariables>(GetPlanOfferToEditVestingEventsEsopDocument, options);\n      }\nexport function useGetPlanOfferToEditVestingEventsEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOfferToEditVestingEventsEsopQuery, GetPlanOfferToEditVestingEventsEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOfferToEditVestingEventsEsopQuery, GetPlanOfferToEditVestingEventsEsopQueryVariables>(GetPlanOfferToEditVestingEventsEsopDocument, options);\n        }\nexport function useGetPlanOfferToEditVestingEventsEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOfferToEditVestingEventsEsopQuery, GetPlanOfferToEditVestingEventsEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOfferToEditVestingEventsEsopQuery, GetPlanOfferToEditVestingEventsEsopQueryVariables>(GetPlanOfferToEditVestingEventsEsopDocument, options);\n        }\nexport type GetPlanOfferToEditVestingEventsEsopQueryHookResult = ReturnType<typeof useGetPlanOfferToEditVestingEventsEsopQuery>;\nexport type GetPlanOfferToEditVestingEventsEsopLazyQueryHookResult = ReturnType<typeof useGetPlanOfferToEditVestingEventsEsopLazyQuery>;\nexport type GetPlanOfferToEditVestingEventsEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlanOfferToEditVestingEventsEsopSuspenseQuery>;\nexport type GetPlanOfferToEditVestingEventsEsopQueryResult = Apollo.QueryResult<GetPlanOfferToEditVestingEventsEsopQuery, GetPlanOfferToEditVestingEventsEsopQueryVariables>;\nexport function refetchGetPlanOfferToEditVestingEventsEsopQuery(variables: GetPlanOfferToEditVestingEventsEsopQueryVariables) {\n      return { query: GetPlanOfferToEditVestingEventsEsopDocument, variables: variables };\n    }\nexport const CheckOffersPostGrantGrantDateEditabilityEsopDocument: TypedDocumentNode<CheckOffersPostGrantGrantDateEditabilityEsopQuery, CheckOffersPostGrantGrantDateEditabilityEsopQueryVariables> = gql`\n  query checkOffersPostGrantGrantDateEditabilityESOP($page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $offerIds: [UUID]!, $plan: EsopCakeType!, $offerGroup: EsopOfferGroupCakeType) {\n  checkOffersEditability: offersPostGrantGrantDateEditabilityEsop(\n    page: $page\n    itemsPerPage: $itemsPerPage\n    offerIds: $offerIds\n    plan: $plan\n    offerGroup: $offerGroup\n  ) {\n    currentPage\n    count\n    uneditableCount\n    pageData {\n      offerId\n      displayName\n      email\n      avatar\n      canEdit\n      reasons\n    }\n  }\n}\n    `;\n\n/**\n * __useCheckOffersPostGrantGrantDateEditabilityEsopQuery__\n *\n * To run a query within a React component, call `useCheckOffersPostGrantGrantDateEditabilityEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useCheckOffersPostGrantGrantDateEditabilityEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCheckOffersPostGrantGrantDateEditabilityEsopQuery({\n *   variables: {\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      offerIds: // value for 'offerIds'\n *      plan: // value for 'plan'\n *      offerGroup: // value for 'offerGroup'\n *   },\n * });\n */\nexport function useCheckOffersPostGrantGrantDateEditabilityEsopQuery(baseOptions: Apollo.QueryHookOptions<CheckOffersPostGrantGrantDateEditabilityEsopQuery, CheckOffersPostGrantGrantDateEditabilityEsopQueryVariables> & ({ variables: CheckOffersPostGrantGrantDateEditabilityEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<CheckOffersPostGrantGrantDateEditabilityEsopQuery, CheckOffersPostGrantGrantDateEditabilityEsopQueryVariables>(CheckOffersPostGrantGrantDateEditabilityEsopDocument, options);\n      }\nexport function useCheckOffersPostGrantGrantDateEditabilityEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CheckOffersPostGrantGrantDateEditabilityEsopQuery, CheckOffersPostGrantGrantDateEditabilityEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<CheckOffersPostGrantGrantDateEditabilityEsopQuery, CheckOffersPostGrantGrantDateEditabilityEsopQueryVariables>(CheckOffersPostGrantGrantDateEditabilityEsopDocument, options);\n        }\nexport function useCheckOffersPostGrantGrantDateEditabilityEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<CheckOffersPostGrantGrantDateEditabilityEsopQuery, CheckOffersPostGrantGrantDateEditabilityEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<CheckOffersPostGrantGrantDateEditabilityEsopQuery, CheckOffersPostGrantGrantDateEditabilityEsopQueryVariables>(CheckOffersPostGrantGrantDateEditabilityEsopDocument, options);\n        }\nexport type CheckOffersPostGrantGrantDateEditabilityEsopQueryHookResult = ReturnType<typeof useCheckOffersPostGrantGrantDateEditabilityEsopQuery>;\nexport type CheckOffersPostGrantGrantDateEditabilityEsopLazyQueryHookResult = ReturnType<typeof useCheckOffersPostGrantGrantDateEditabilityEsopLazyQuery>;\nexport type CheckOffersPostGrantGrantDateEditabilityEsopSuspenseQueryHookResult = ReturnType<typeof useCheckOffersPostGrantGrantDateEditabilityEsopSuspenseQuery>;\nexport type CheckOffersPostGrantGrantDateEditabilityEsopQueryResult = Apollo.QueryResult<CheckOffersPostGrantGrantDateEditabilityEsopQuery, CheckOffersPostGrantGrantDateEditabilityEsopQueryVariables>;\nexport function refetchCheckOffersPostGrantGrantDateEditabilityEsopQuery(variables: CheckOffersPostGrantGrantDateEditabilityEsopQueryVariables) {\n      return { query: CheckOffersPostGrantGrantDateEditabilityEsopDocument, variables: variables };\n    }\nexport const CheckOffersPostGrantOptionPriceEditabilityEsopDocument: TypedDocumentNode<CheckOffersPostGrantOptionPriceEditabilityEsopQuery, CheckOffersPostGrantOptionPriceEditabilityEsopQueryVariables> = gql`\n  query checkOffersPostGrantOptionPriceEditabilityESOP($page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $offerIds: [UUID]!, $plan: EsopCakeType!, $offerGroup: EsopOfferGroupCakeType) {\n  checkOffersEditability: offersPostGrantOptionPriceEditabilityEsop(\n    page: $page\n    itemsPerPage: $itemsPerPage\n    offerIds: $offerIds\n    plan: $plan\n    offerGroup: $offerGroup\n  ) {\n    currentPage\n    count\n    uneditableCount\n    pageData {\n      offerId\n      displayName\n      email\n      avatar\n      canEdit\n      reasons\n    }\n  }\n}\n    `;\n\n/**\n * __useCheckOffersPostGrantOptionPriceEditabilityEsopQuery__\n *\n * To run a query within a React component, call `useCheckOffersPostGrantOptionPriceEditabilityEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useCheckOffersPostGrantOptionPriceEditabilityEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCheckOffersPostGrantOptionPriceEditabilityEsopQuery({\n *   variables: {\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      offerIds: // value for 'offerIds'\n *      plan: // value for 'plan'\n *      offerGroup: // value for 'offerGroup'\n *   },\n * });\n */\nexport function useCheckOffersPostGrantOptionPriceEditabilityEsopQuery(baseOptions: Apollo.QueryHookOptions<CheckOffersPostGrantOptionPriceEditabilityEsopQuery, CheckOffersPostGrantOptionPriceEditabilityEsopQueryVariables> & ({ variables: CheckOffersPostGrantOptionPriceEditabilityEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<CheckOffersPostGrantOptionPriceEditabilityEsopQuery, CheckOffersPostGrantOptionPriceEditabilityEsopQueryVariables>(CheckOffersPostGrantOptionPriceEditabilityEsopDocument, options);\n      }\nexport function useCheckOffersPostGrantOptionPriceEditabilityEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CheckOffersPostGrantOptionPriceEditabilityEsopQuery, CheckOffersPostGrantOptionPriceEditabilityEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<CheckOffersPostGrantOptionPriceEditabilityEsopQuery, CheckOffersPostGrantOptionPriceEditabilityEsopQueryVariables>(CheckOffersPostGrantOptionPriceEditabilityEsopDocument, options);\n        }\nexport function useCheckOffersPostGrantOptionPriceEditabilityEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<CheckOffersPostGrantOptionPriceEditabilityEsopQuery, CheckOffersPostGrantOptionPriceEditabilityEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<CheckOffersPostGrantOptionPriceEditabilityEsopQuery, CheckOffersPostGrantOptionPriceEditabilityEsopQueryVariables>(CheckOffersPostGrantOptionPriceEditabilityEsopDocument, options);\n        }\nexport type CheckOffersPostGrantOptionPriceEditabilityEsopQueryHookResult = ReturnType<typeof useCheckOffersPostGrantOptionPriceEditabilityEsopQuery>;\nexport type CheckOffersPostGrantOptionPriceEditabilityEsopLazyQueryHookResult = ReturnType<typeof useCheckOffersPostGrantOptionPriceEditabilityEsopLazyQuery>;\nexport type CheckOffersPostGrantOptionPriceEditabilityEsopSuspenseQueryHookResult = ReturnType<typeof useCheckOffersPostGrantOptionPriceEditabilityEsopSuspenseQuery>;\nexport type CheckOffersPostGrantOptionPriceEditabilityEsopQueryResult = Apollo.QueryResult<CheckOffersPostGrantOptionPriceEditabilityEsopQuery, CheckOffersPostGrantOptionPriceEditabilityEsopQueryVariables>;\nexport function refetchCheckOffersPostGrantOptionPriceEditabilityEsopQuery(variables: CheckOffersPostGrantOptionPriceEditabilityEsopQueryVariables) {\n      return { query: CheckOffersPostGrantOptionPriceEditabilityEsopDocument, variables: variables };\n    }\nexport const CheckOffersPostGrantExercisePriceEditabilityEsopDocument: TypedDocumentNode<CheckOffersPostGrantExercisePriceEditabilityEsopQuery, CheckOffersPostGrantExercisePriceEditabilityEsopQueryVariables> = gql`\n  query checkOffersPostGrantExercisePriceEditabilityESOP($page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $offerIds: [UUID]!, $plan: EsopCakeType!, $offerGroup: EsopOfferGroupCakeType) {\n  checkOffersEditability: offersPostGrantExercisePriceEditabilityEsop(\n    page: $page\n    itemsPerPage: $itemsPerPage\n    offerIds: $offerIds\n    plan: $plan\n    offerGroup: $offerGroup\n  ) {\n    currentPage\n    count\n    uneditableCount\n    pageData {\n      offerId\n      displayName\n      email\n      avatar\n      canEdit\n      reasons\n    }\n  }\n}\n    `;\n\n/**\n * __useCheckOffersPostGrantExercisePriceEditabilityEsopQuery__\n *\n * To run a query within a React component, call `useCheckOffersPostGrantExercisePriceEditabilityEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useCheckOffersPostGrantExercisePriceEditabilityEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCheckOffersPostGrantExercisePriceEditabilityEsopQuery({\n *   variables: {\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      offerIds: // value for 'offerIds'\n *      plan: // value for 'plan'\n *      offerGroup: // value for 'offerGroup'\n *   },\n * });\n */\nexport function useCheckOffersPostGrantExercisePriceEditabilityEsopQuery(baseOptions: Apollo.QueryHookOptions<CheckOffersPostGrantExercisePriceEditabilityEsopQuery, CheckOffersPostGrantExercisePriceEditabilityEsopQueryVariables> & ({ variables: CheckOffersPostGrantExercisePriceEditabilityEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<CheckOffersPostGrantExercisePriceEditabilityEsopQuery, CheckOffersPostGrantExercisePriceEditabilityEsopQueryVariables>(CheckOffersPostGrantExercisePriceEditabilityEsopDocument, options);\n      }\nexport function useCheckOffersPostGrantExercisePriceEditabilityEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CheckOffersPostGrantExercisePriceEditabilityEsopQuery, CheckOffersPostGrantExercisePriceEditabilityEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<CheckOffersPostGrantExercisePriceEditabilityEsopQuery, CheckOffersPostGrantExercisePriceEditabilityEsopQueryVariables>(CheckOffersPostGrantExercisePriceEditabilityEsopDocument, options);\n        }\nexport function useCheckOffersPostGrantExercisePriceEditabilityEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<CheckOffersPostGrantExercisePriceEditabilityEsopQuery, CheckOffersPostGrantExercisePriceEditabilityEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<CheckOffersPostGrantExercisePriceEditabilityEsopQuery, CheckOffersPostGrantExercisePriceEditabilityEsopQueryVariables>(CheckOffersPostGrantExercisePriceEditabilityEsopDocument, options);\n        }\nexport type CheckOffersPostGrantExercisePriceEditabilityEsopQueryHookResult = ReturnType<typeof useCheckOffersPostGrantExercisePriceEditabilityEsopQuery>;\nexport type CheckOffersPostGrantExercisePriceEditabilityEsopLazyQueryHookResult = ReturnType<typeof useCheckOffersPostGrantExercisePriceEditabilityEsopLazyQuery>;\nexport type CheckOffersPostGrantExercisePriceEditabilityEsopSuspenseQueryHookResult = ReturnType<typeof useCheckOffersPostGrantExercisePriceEditabilityEsopSuspenseQuery>;\nexport type CheckOffersPostGrantExercisePriceEditabilityEsopQueryResult = Apollo.QueryResult<CheckOffersPostGrantExercisePriceEditabilityEsopQuery, CheckOffersPostGrantExercisePriceEditabilityEsopQueryVariables>;\nexport function refetchCheckOffersPostGrantExercisePriceEditabilityEsopQuery(variables: CheckOffersPostGrantExercisePriceEditabilityEsopQueryVariables) {\n      return { query: CheckOffersPostGrantExercisePriceEditabilityEsopDocument, variables: variables };\n    }\nexport const CheckOffersPostGrantExpirationEditabilityEsopDocument: TypedDocumentNode<CheckOffersPostGrantExpirationEditabilityEsopQuery, CheckOffersPostGrantExpirationEditabilityEsopQueryVariables> = gql`\n  query checkOffersPostGrantExpirationEditabilityESOP($page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $offerIds: [UUID]!, $plan: EsopCakeType!, $offerGroup: EsopOfferGroupCakeType, $expirationData: OfferExerciseExpirationDataInputType!) {\n  checkOffersEditability: offersPostGrantExpirationEditabilityEsop(\n    page: $page\n    itemsPerPage: $itemsPerPage\n    offerIds: $offerIds\n    plan: $plan\n    offerGroup: $offerGroup\n    expirationData: $expirationData\n  ) {\n    currentPage\n    count\n    uneditableCount\n    pageData {\n      offerId\n      displayName\n      email\n      avatar\n      canEdit\n      reasons\n    }\n  }\n}\n    `;\n\n/**\n * __useCheckOffersPostGrantExpirationEditabilityEsopQuery__\n *\n * To run a query within a React component, call `useCheckOffersPostGrantExpirationEditabilityEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useCheckOffersPostGrantExpirationEditabilityEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCheckOffersPostGrantExpirationEditabilityEsopQuery({\n *   variables: {\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      offerIds: // value for 'offerIds'\n *      plan: // value for 'plan'\n *      offerGroup: // value for 'offerGroup'\n *      expirationData: // value for 'expirationData'\n *   },\n * });\n */\nexport function useCheckOffersPostGrantExpirationEditabilityEsopQuery(baseOptions: Apollo.QueryHookOptions<CheckOffersPostGrantExpirationEditabilityEsopQuery, CheckOffersPostGrantExpirationEditabilityEsopQueryVariables> & ({ variables: CheckOffersPostGrantExpirationEditabilityEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<CheckOffersPostGrantExpirationEditabilityEsopQuery, CheckOffersPostGrantExpirationEditabilityEsopQueryVariables>(CheckOffersPostGrantExpirationEditabilityEsopDocument, options);\n      }\nexport function useCheckOffersPostGrantExpirationEditabilityEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CheckOffersPostGrantExpirationEditabilityEsopQuery, CheckOffersPostGrantExpirationEditabilityEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<CheckOffersPostGrantExpirationEditabilityEsopQuery, CheckOffersPostGrantExpirationEditabilityEsopQueryVariables>(CheckOffersPostGrantExpirationEditabilityEsopDocument, options);\n        }\nexport function useCheckOffersPostGrantExpirationEditabilityEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<CheckOffersPostGrantExpirationEditabilityEsopQuery, CheckOffersPostGrantExpirationEditabilityEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<CheckOffersPostGrantExpirationEditabilityEsopQuery, CheckOffersPostGrantExpirationEditabilityEsopQueryVariables>(CheckOffersPostGrantExpirationEditabilityEsopDocument, options);\n        }\nexport type CheckOffersPostGrantExpirationEditabilityEsopQueryHookResult = ReturnType<typeof useCheckOffersPostGrantExpirationEditabilityEsopQuery>;\nexport type CheckOffersPostGrantExpirationEditabilityEsopLazyQueryHookResult = ReturnType<typeof useCheckOffersPostGrantExpirationEditabilityEsopLazyQuery>;\nexport type CheckOffersPostGrantExpirationEditabilityEsopSuspenseQueryHookResult = ReturnType<typeof useCheckOffersPostGrantExpirationEditabilityEsopSuspenseQuery>;\nexport type CheckOffersPostGrantExpirationEditabilityEsopQueryResult = Apollo.QueryResult<CheckOffersPostGrantExpirationEditabilityEsopQuery, CheckOffersPostGrantExpirationEditabilityEsopQueryVariables>;\nexport function refetchCheckOffersPostGrantExpirationEditabilityEsopQuery(variables: CheckOffersPostGrantExpirationEditabilityEsopQueryVariables) {\n      return { query: CheckOffersPostGrantExpirationEditabilityEsopDocument, variables: variables };\n    }\nexport const CheckOffersBulkPostGrantPtepEditabilityEsopDocument: TypedDocumentNode<CheckOffersBulkPostGrantPtepEditabilityEsopQuery, CheckOffersBulkPostGrantPtepEditabilityEsopQueryVariables> = gql`\n  query checkOffersBulkPostGrantPtepEditabilityESOP($page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $offerIds: [UUID]!, $plan: EsopCakeType!, $offerGroup: EsopOfferGroupCakeType) {\n  checkOffersEditability: offersPostGrantPtepEditabilityEsop(\n    page: $page\n    itemsPerPage: $itemsPerPage\n    offerIds: $offerIds\n    plan: $plan\n    offerGroup: $offerGroup\n  ) {\n    currentPage\n    count\n    uneditableCount\n    pageData {\n      offerId\n      displayName\n      email\n      avatar\n      canEdit\n      reasons\n    }\n  }\n}\n    `;\n\n/**\n * __useCheckOffersBulkPostGrantPtepEditabilityEsopQuery__\n *\n * To run a query within a React component, call `useCheckOffersBulkPostGrantPtepEditabilityEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useCheckOffersBulkPostGrantPtepEditabilityEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCheckOffersBulkPostGrantPtepEditabilityEsopQuery({\n *   variables: {\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      offerIds: // value for 'offerIds'\n *      plan: // value for 'plan'\n *      offerGroup: // value for 'offerGroup'\n *   },\n * });\n */\nexport function useCheckOffersBulkPostGrantPtepEditabilityEsopQuery(baseOptions: Apollo.QueryHookOptions<CheckOffersBulkPostGrantPtepEditabilityEsopQuery, CheckOffersBulkPostGrantPtepEditabilityEsopQueryVariables> & ({ variables: CheckOffersBulkPostGrantPtepEditabilityEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<CheckOffersBulkPostGrantPtepEditabilityEsopQuery, CheckOffersBulkPostGrantPtepEditabilityEsopQueryVariables>(CheckOffersBulkPostGrantPtepEditabilityEsopDocument, options);\n      }\nexport function useCheckOffersBulkPostGrantPtepEditabilityEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CheckOffersBulkPostGrantPtepEditabilityEsopQuery, CheckOffersBulkPostGrantPtepEditabilityEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<CheckOffersBulkPostGrantPtepEditabilityEsopQuery, CheckOffersBulkPostGrantPtepEditabilityEsopQueryVariables>(CheckOffersBulkPostGrantPtepEditabilityEsopDocument, options);\n        }\nexport function useCheckOffersBulkPostGrantPtepEditabilityEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<CheckOffersBulkPostGrantPtepEditabilityEsopQuery, CheckOffersBulkPostGrantPtepEditabilityEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<CheckOffersBulkPostGrantPtepEditabilityEsopQuery, CheckOffersBulkPostGrantPtepEditabilityEsopQueryVariables>(CheckOffersBulkPostGrantPtepEditabilityEsopDocument, options);\n        }\nexport type CheckOffersBulkPostGrantPtepEditabilityEsopQueryHookResult = ReturnType<typeof useCheckOffersBulkPostGrantPtepEditabilityEsopQuery>;\nexport type CheckOffersBulkPostGrantPtepEditabilityEsopLazyQueryHookResult = ReturnType<typeof useCheckOffersBulkPostGrantPtepEditabilityEsopLazyQuery>;\nexport type CheckOffersBulkPostGrantPtepEditabilityEsopSuspenseQueryHookResult = ReturnType<typeof useCheckOffersBulkPostGrantPtepEditabilityEsopSuspenseQuery>;\nexport type CheckOffersBulkPostGrantPtepEditabilityEsopQueryResult = Apollo.QueryResult<CheckOffersBulkPostGrantPtepEditabilityEsopQuery, CheckOffersBulkPostGrantPtepEditabilityEsopQueryVariables>;\nexport function refetchCheckOffersBulkPostGrantPtepEditabilityEsopQuery(variables: CheckOffersBulkPostGrantPtepEditabilityEsopQueryVariables) {\n      return { query: CheckOffersBulkPostGrantPtepEditabilityEsopDocument, variables: variables };\n    }\nexport const CheckOfferPostGrantPtepEditabilityEsopDocument: TypedDocumentNode<CheckOfferPostGrantPtepEditabilityEsopQuery, CheckOfferPostGrantPtepEditabilityEsopQueryVariables> = gql`\n  query checkOfferPostGrantPtepEditabilityESOP($page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $offerId: UUID!, $plan: EsopCakeType!, $offerGroup: EsopOfferGroupCakeType) {\n  checkOffersEditability: offersPostGrantPtepEditabilityEsop(\n    page: $page\n    itemsPerPage: $itemsPerPage\n    offerIds: [$offerId]\n    plan: $plan\n    offerGroup: $offerGroup\n  ) {\n    currentPage\n    count\n    uneditableCount\n    pageData {\n      offerId\n      displayName\n      email\n      avatar\n      canEdit\n      reasons\n    }\n  }\n  offer: esopOffer(offerId: $offerId) {\n    id\n    ptepSettings {\n      ptepInterval {\n        quantity\n        unit\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useCheckOfferPostGrantPtepEditabilityEsopQuery__\n *\n * To run a query within a React component, call `useCheckOfferPostGrantPtepEditabilityEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useCheckOfferPostGrantPtepEditabilityEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useCheckOfferPostGrantPtepEditabilityEsopQuery({\n *   variables: {\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      offerId: // value for 'offerId'\n *      plan: // value for 'plan'\n *      offerGroup: // value for 'offerGroup'\n *   },\n * });\n */\nexport function useCheckOfferPostGrantPtepEditabilityEsopQuery(baseOptions: Apollo.QueryHookOptions<CheckOfferPostGrantPtepEditabilityEsopQuery, CheckOfferPostGrantPtepEditabilityEsopQueryVariables> & ({ variables: CheckOfferPostGrantPtepEditabilityEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<CheckOfferPostGrantPtepEditabilityEsopQuery, CheckOfferPostGrantPtepEditabilityEsopQueryVariables>(CheckOfferPostGrantPtepEditabilityEsopDocument, options);\n      }\nexport function useCheckOfferPostGrantPtepEditabilityEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CheckOfferPostGrantPtepEditabilityEsopQuery, CheckOfferPostGrantPtepEditabilityEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<CheckOfferPostGrantPtepEditabilityEsopQuery, CheckOfferPostGrantPtepEditabilityEsopQueryVariables>(CheckOfferPostGrantPtepEditabilityEsopDocument, options);\n        }\nexport function useCheckOfferPostGrantPtepEditabilityEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<CheckOfferPostGrantPtepEditabilityEsopQuery, CheckOfferPostGrantPtepEditabilityEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<CheckOfferPostGrantPtepEditabilityEsopQuery, CheckOfferPostGrantPtepEditabilityEsopQueryVariables>(CheckOfferPostGrantPtepEditabilityEsopDocument, options);\n        }\nexport type CheckOfferPostGrantPtepEditabilityEsopQueryHookResult = ReturnType<typeof useCheckOfferPostGrantPtepEditabilityEsopQuery>;\nexport type CheckOfferPostGrantPtepEditabilityEsopLazyQueryHookResult = ReturnType<typeof useCheckOfferPostGrantPtepEditabilityEsopLazyQuery>;\nexport type CheckOfferPostGrantPtepEditabilityEsopSuspenseQueryHookResult = ReturnType<typeof useCheckOfferPostGrantPtepEditabilityEsopSuspenseQuery>;\nexport type CheckOfferPostGrantPtepEditabilityEsopQueryResult = Apollo.QueryResult<CheckOfferPostGrantPtepEditabilityEsopQuery, CheckOfferPostGrantPtepEditabilityEsopQueryVariables>;\nexport function refetchCheckOfferPostGrantPtepEditabilityEsopQuery(variables: CheckOfferPostGrantPtepEditabilityEsopQueryVariables) {\n      return { query: CheckOfferPostGrantPtepEditabilityEsopDocument, variables: variables };\n    }\nexport const EditPostGrantDateEsopDocument: TypedDocumentNode<EditPostGrantDateEsopMutation, EditPostGrantDateEsopMutationVariables> = gql`\n  mutation editPostGrantDateESOP($offerIds: [UUID]!, $grantDate: Date!, $planType: EsopCakeType!, $group: EsopOfferGroupCakeType, $excludeIds: [UUID]) {\n  editPostGrantGrantDateEsop(\n    offerIds: $offerIds\n    grantDate: $grantDate\n    plan: $planType\n    offerGroup: $group\n    excludeIds: $excludeIds\n  )\n}\n    `;\nexport type EditPostGrantDateEsopMutationFn = Apollo.MutationFunction<EditPostGrantDateEsopMutation, EditPostGrantDateEsopMutationVariables>;\n\n/**\n * __useEditPostGrantDateEsopMutation__\n *\n * To run a mutation, you first call `useEditPostGrantDateEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditPostGrantDateEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editPostGrantDateEsopMutation, { data, loading, error }] = useEditPostGrantDateEsopMutation({\n *   variables: {\n *      offerIds: // value for 'offerIds'\n *      grantDate: // value for 'grantDate'\n *      planType: // value for 'planType'\n *      group: // value for 'group'\n *      excludeIds: // value for 'excludeIds'\n *   },\n * });\n */\nexport function useEditPostGrantDateEsopMutation(baseOptions?: Apollo.MutationHookOptions<EditPostGrantDateEsopMutation, EditPostGrantDateEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditPostGrantDateEsopMutation, EditPostGrantDateEsopMutationVariables>(EditPostGrantDateEsopDocument, options);\n      }\nexport type EditPostGrantDateEsopMutationHookResult = ReturnType<typeof useEditPostGrantDateEsopMutation>;\nexport type EditPostGrantDateEsopMutationResult = Apollo.MutationResult<EditPostGrantDateEsopMutation>;\nexport type EditPostGrantDateEsopMutationOptions = Apollo.BaseMutationOptions<EditPostGrantDateEsopMutation, EditPostGrantDateEsopMutationVariables>;\nexport const EditPostVestDateEsopDocument: TypedDocumentNode<EditPostVestDateEsopMutation, EditPostVestDateEsopMutationVariables> = gql`\n  mutation editPostVestDateESOP($offer: EsopOfferCakeType!, $vestStartDate: Date!) {\n  editPostGrantVestStartDateEsop(offer: $offer, vestStartDate: $vestStartDate)\n}\n    `;\nexport type EditPostVestDateEsopMutationFn = Apollo.MutationFunction<EditPostVestDateEsopMutation, EditPostVestDateEsopMutationVariables>;\n\n/**\n * __useEditPostVestDateEsopMutation__\n *\n * To run a mutation, you first call `useEditPostVestDateEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditPostVestDateEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editPostVestDateEsopMutation, { data, loading, error }] = useEditPostVestDateEsopMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      vestStartDate: // value for 'vestStartDate'\n *   },\n * });\n */\nexport function useEditPostVestDateEsopMutation(baseOptions?: Apollo.MutationHookOptions<EditPostVestDateEsopMutation, EditPostVestDateEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditPostVestDateEsopMutation, EditPostVestDateEsopMutationVariables>(EditPostVestDateEsopDocument, options);\n      }\nexport type EditPostVestDateEsopMutationHookResult = ReturnType<typeof useEditPostVestDateEsopMutation>;\nexport type EditPostVestDateEsopMutationResult = Apollo.MutationResult<EditPostVestDateEsopMutation>;\nexport type EditPostVestDateEsopMutationOptions = Apollo.BaseMutationOptions<EditPostVestDateEsopMutation, EditPostVestDateEsopMutationVariables>;\nexport const EditPostGrantOptionPriceEsopDocument: TypedDocumentNode<EditPostGrantOptionPriceEsopMutation, EditPostGrantOptionPriceEsopMutationVariables> = gql`\n  mutation editPostGrantOptionPriceESOP($offerIds: [UUID]!, $optionPrice: CakeDecimal!, $plan: EsopCakeType!, $group: EsopOfferGroupCakeType, $excludeIds: [UUID]) {\n  editPostGrantOptionPriceEsop(\n    offerIds: $offerIds\n    optionPrice: $optionPrice\n    plan: $plan\n    offerGroup: $group\n    excludeIds: $excludeIds\n  )\n}\n    `;\nexport type EditPostGrantOptionPriceEsopMutationFn = Apollo.MutationFunction<EditPostGrantOptionPriceEsopMutation, EditPostGrantOptionPriceEsopMutationVariables>;\n\n/**\n * __useEditPostGrantOptionPriceEsopMutation__\n *\n * To run a mutation, you first call `useEditPostGrantOptionPriceEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditPostGrantOptionPriceEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editPostGrantOptionPriceEsopMutation, { data, loading, error }] = useEditPostGrantOptionPriceEsopMutation({\n *   variables: {\n *      offerIds: // value for 'offerIds'\n *      optionPrice: // value for 'optionPrice'\n *      plan: // value for 'plan'\n *      group: // value for 'group'\n *      excludeIds: // value for 'excludeIds'\n *   },\n * });\n */\nexport function useEditPostGrantOptionPriceEsopMutation(baseOptions?: Apollo.MutationHookOptions<EditPostGrantOptionPriceEsopMutation, EditPostGrantOptionPriceEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditPostGrantOptionPriceEsopMutation, EditPostGrantOptionPriceEsopMutationVariables>(EditPostGrantOptionPriceEsopDocument, options);\n      }\nexport type EditPostGrantOptionPriceEsopMutationHookResult = ReturnType<typeof useEditPostGrantOptionPriceEsopMutation>;\nexport type EditPostGrantOptionPriceEsopMutationResult = Apollo.MutationResult<EditPostGrantOptionPriceEsopMutation>;\nexport type EditPostGrantOptionPriceEsopMutationOptions = Apollo.BaseMutationOptions<EditPostGrantOptionPriceEsopMutation, EditPostGrantOptionPriceEsopMutationVariables>;\nexport const EditPostGrantExercisePriceEsopDocument: TypedDocumentNode<EditPostGrantExercisePriceEsopMutation, EditPostGrantExercisePriceEsopMutationVariables> = gql`\n  mutation editPostGrantExercisePriceESOP($offerIds: [UUID]!, $exercisePrice: CakeDecimal!, $plan: EsopCakeType!, $group: EsopOfferGroupCakeType, $excludeIds: [UUID], $attachment: DocumentCakeType, $repriceTransactionDate: Date) {\n  editPostGrantExercisePriceEsop(\n    offerIds: $offerIds\n    exercisePrice: $exercisePrice\n    plan: $plan\n    offerGroup: $group\n    excludeIds: $excludeIds\n    attachment: $attachment\n    repriceTransactionDate: $repriceTransactionDate\n  )\n}\n    `;\nexport type EditPostGrantExercisePriceEsopMutationFn = Apollo.MutationFunction<EditPostGrantExercisePriceEsopMutation, EditPostGrantExercisePriceEsopMutationVariables>;\n\n/**\n * __useEditPostGrantExercisePriceEsopMutation__\n *\n * To run a mutation, you first call `useEditPostGrantExercisePriceEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditPostGrantExercisePriceEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editPostGrantExercisePriceEsopMutation, { data, loading, error }] = useEditPostGrantExercisePriceEsopMutation({\n *   variables: {\n *      offerIds: // value for 'offerIds'\n *      exercisePrice: // value for 'exercisePrice'\n *      plan: // value for 'plan'\n *      group: // value for 'group'\n *      excludeIds: // value for 'excludeIds'\n *      attachment: // value for 'attachment'\n *      repriceTransactionDate: // value for 'repriceTransactionDate'\n *   },\n * });\n */\nexport function useEditPostGrantExercisePriceEsopMutation(baseOptions?: Apollo.MutationHookOptions<EditPostGrantExercisePriceEsopMutation, EditPostGrantExercisePriceEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditPostGrantExercisePriceEsopMutation, EditPostGrantExercisePriceEsopMutationVariables>(EditPostGrantExercisePriceEsopDocument, options);\n      }\nexport type EditPostGrantExercisePriceEsopMutationHookResult = ReturnType<typeof useEditPostGrantExercisePriceEsopMutation>;\nexport type EditPostGrantExercisePriceEsopMutationResult = Apollo.MutationResult<EditPostGrantExercisePriceEsopMutation>;\nexport type EditPostGrantExercisePriceEsopMutationOptions = Apollo.BaseMutationOptions<EditPostGrantExercisePriceEsopMutation, EditPostGrantExercisePriceEsopMutationVariables>;\nexport const EditPostGrantExpirationEsopDocument: TypedDocumentNode<EditPostGrantExpirationEsopMutation, EditPostGrantExpirationEsopMutationVariables> = gql`\n  mutation editPostGrantExpirationESOP($offerIds: [UUID]!, $exerciseExpirationData: OfferExerciseExpirationDataInputType!, $plan: EsopCakeType!, $excludeIds: [UUID]) {\n  editPostGrantExpirationEsop(\n    offerIds: $offerIds\n    exerciseExpirationData: $exerciseExpirationData\n    plan: $plan\n    excludeIds: $excludeIds\n  )\n}\n    `;\nexport type EditPostGrantExpirationEsopMutationFn = Apollo.MutationFunction<EditPostGrantExpirationEsopMutation, EditPostGrantExpirationEsopMutationVariables>;\n\n/**\n * __useEditPostGrantExpirationEsopMutation__\n *\n * To run a mutation, you first call `useEditPostGrantExpirationEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditPostGrantExpirationEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editPostGrantExpirationEsopMutation, { data, loading, error }] = useEditPostGrantExpirationEsopMutation({\n *   variables: {\n *      offerIds: // value for 'offerIds'\n *      exerciseExpirationData: // value for 'exerciseExpirationData'\n *      plan: // value for 'plan'\n *      excludeIds: // value for 'excludeIds'\n *   },\n * });\n */\nexport function useEditPostGrantExpirationEsopMutation(baseOptions?: Apollo.MutationHookOptions<EditPostGrantExpirationEsopMutation, EditPostGrantExpirationEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditPostGrantExpirationEsopMutation, EditPostGrantExpirationEsopMutationVariables>(EditPostGrantExpirationEsopDocument, options);\n      }\nexport type EditPostGrantExpirationEsopMutationHookResult = ReturnType<typeof useEditPostGrantExpirationEsopMutation>;\nexport type EditPostGrantExpirationEsopMutationResult = Apollo.MutationResult<EditPostGrantExpirationEsopMutation>;\nexport type EditPostGrantExpirationEsopMutationOptions = Apollo.BaseMutationOptions<EditPostGrantExpirationEsopMutation, EditPostGrantExpirationEsopMutationVariables>;\nexport const EditPostGrantPtepEsopDocument: TypedDocumentNode<EditPostGrantPtepEsopMutation, EditPostGrantPtepEsopMutationVariables> = gql`\n  mutation editPostGrantPtepESOP($offerIds: [UUID]!, $ptep: TimeSliceInputType, $plan: EsopCakeType!, $group: EsopOfferGroupCakeType, $excludeIds: [UUID]) {\n  editPostGrantPtepEsop(\n    offerIds: $offerIds\n    ptep: $ptep\n    plan: $plan\n    offerGroup: $group\n    excludeIds: $excludeIds\n  )\n}\n    `;\nexport type EditPostGrantPtepEsopMutationFn = Apollo.MutationFunction<EditPostGrantPtepEsopMutation, EditPostGrantPtepEsopMutationVariables>;\n\n/**\n * __useEditPostGrantPtepEsopMutation__\n *\n * To run a mutation, you first call `useEditPostGrantPtepEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditPostGrantPtepEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editPostGrantPtepEsopMutation, { data, loading, error }] = useEditPostGrantPtepEsopMutation({\n *   variables: {\n *      offerIds: // value for 'offerIds'\n *      ptep: // value for 'ptep'\n *      plan: // value for 'plan'\n *      group: // value for 'group'\n *      excludeIds: // value for 'excludeIds'\n *   },\n * });\n */\nexport function useEditPostGrantPtepEsopMutation(baseOptions?: Apollo.MutationHookOptions<EditPostGrantPtepEsopMutation, EditPostGrantPtepEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditPostGrantPtepEsopMutation, EditPostGrantPtepEsopMutationVariables>(EditPostGrantPtepEsopDocument, options);\n      }\nexport type EditPostGrantPtepEsopMutationHookResult = ReturnType<typeof useEditPostGrantPtepEsopMutation>;\nexport type EditPostGrantPtepEsopMutationResult = Apollo.MutationResult<EditPostGrantPtepEsopMutation>;\nexport type EditPostGrantPtepEsopMutationOptions = Apollo.BaseMutationOptions<EditPostGrantPtepEsopMutation, EditPostGrantPtepEsopMutationVariables>;\nexport const EditEsopDocument: TypedDocumentNode<EditEsopMutation, EditEsopMutationVariables> = gql`\n  mutation editESOP($plan: EsopCakeType!, $name: CleanString!, $vestingValue: PositiveInteger!, $requireWitness: Boolean) {\n  editEsop(\n    plan: $plan\n    name: $name\n    vestingValue: $vestingValue\n    requireWitness: $requireWitness\n  )\n}\n    `;\nexport type EditEsopMutationFn = Apollo.MutationFunction<EditEsopMutation, EditEsopMutationVariables>;\n\n/**\n * __useEditEsopMutation__\n *\n * To run a mutation, you first call `useEditEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editEsopMutation, { data, loading, error }] = useEditEsopMutation({\n *   variables: {\n *      plan: // value for 'plan'\n *      name: // value for 'name'\n *      vestingValue: // value for 'vestingValue'\n *      requireWitness: // value for 'requireWitness'\n *   },\n * });\n */\nexport function useEditEsopMutation(baseOptions?: Apollo.MutationHookOptions<EditEsopMutation, EditEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditEsopMutation, EditEsopMutationVariables>(EditEsopDocument, options);\n      }\nexport type EditEsopMutationHookResult = ReturnType<typeof useEditEsopMutation>;\nexport type EditEsopMutationResult = Apollo.MutationResult<EditEsopMutation>;\nexport type EditEsopMutationOptions = Apollo.BaseMutationOptions<EditEsopMutation, EditEsopMutationVariables>;\nexport const EditGroupAndEsopDocument: TypedDocumentNode<EditGroupAndEsopMutation, EditGroupAndEsopMutationVariables> = gql`\n  mutation editGroupAndESOP($plan: EsopCakeType!, $name: CleanString!, $vestingValue: PositiveInteger!, $group: EsopOfferGroupCakeType!, $sharetype: SharetypeCakeType, $allowNomineeTrust: Boolean, $requireBoardApproval: Boolean, $enforceDisclosurePeriod: Boolean, $optionPrice: CakeDecimal, $exercisePrice: CakeDecimal, $restrictionsOnShares: [CleanString], $useGroupCurrency: Boolean, $requireWitness: Boolean, $postTerminationExercisePeriod: TimeSliceInputType, $exerciseExpireData: ExerciseExpireDataInputType, $allowEarlyExercise: Boolean) {\n  editEsop(\n    plan: $plan\n    name: $name\n    vestingValue: $vestingValue\n    requireWitness: $requireWitness\n  )\n  editGroupEsop(\n    group: $group\n    sharetype: $sharetype\n    allowNomineeTrust: $allowNomineeTrust\n    requireBoardApproval: $requireBoardApproval\n    enforceDisclosurePeriod: $enforceDisclosurePeriod\n    optionPrice: $optionPrice\n    exercisePrice: $exercisePrice\n    restrictionsOnShares: $restrictionsOnShares\n    exerciseExpireData: $exerciseExpireData\n    useGroupCurrency: $useGroupCurrency\n    postTerminationExercisePeriod: $postTerminationExercisePeriod\n    allowEarlyExercise: $allowEarlyExercise\n  )\n}\n    `;\nexport type EditGroupAndEsopMutationFn = Apollo.MutationFunction<EditGroupAndEsopMutation, EditGroupAndEsopMutationVariables>;\n\n/**\n * __useEditGroupAndEsopMutation__\n *\n * To run a mutation, you first call `useEditGroupAndEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditGroupAndEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editGroupAndEsopMutation, { data, loading, error }] = useEditGroupAndEsopMutation({\n *   variables: {\n *      plan: // value for 'plan'\n *      name: // value for 'name'\n *      vestingValue: // value for 'vestingValue'\n *      group: // value for 'group'\n *      sharetype: // value for 'sharetype'\n *      allowNomineeTrust: // value for 'allowNomineeTrust'\n *      requireBoardApproval: // value for 'requireBoardApproval'\n *      enforceDisclosurePeriod: // value for 'enforceDisclosurePeriod'\n *      optionPrice: // value for 'optionPrice'\n *      exercisePrice: // value for 'exercisePrice'\n *      restrictionsOnShares: // value for 'restrictionsOnShares'\n *      useGroupCurrency: // value for 'useGroupCurrency'\n *      requireWitness: // value for 'requireWitness'\n *      postTerminationExercisePeriod: // value for 'postTerminationExercisePeriod'\n *      exerciseExpireData: // value for 'exerciseExpireData'\n *      allowEarlyExercise: // value for 'allowEarlyExercise'\n *   },\n * });\n */\nexport function useEditGroupAndEsopMutation(baseOptions?: Apollo.MutationHookOptions<EditGroupAndEsopMutation, EditGroupAndEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditGroupAndEsopMutation, EditGroupAndEsopMutationVariables>(EditGroupAndEsopDocument, options);\n      }\nexport type EditGroupAndEsopMutationHookResult = ReturnType<typeof useEditGroupAndEsopMutation>;\nexport type EditGroupAndEsopMutationResult = Apollo.MutationResult<EditGroupAndEsopMutation>;\nexport type EditGroupAndEsopMutationOptions = Apollo.BaseMutationOptions<EditGroupAndEsopMutation, EditGroupAndEsopMutationVariables>;\nexport const DeleteEsopDocument: TypedDocumentNode<DeleteEsopMutation, DeleteEsopMutationVariables> = gql`\n  mutation deleteESOP($plan: EsopCakeType!) {\n  deleteEsop(plan: $plan)\n}\n    `;\nexport type DeleteEsopMutationFn = Apollo.MutationFunction<DeleteEsopMutation, DeleteEsopMutationVariables>;\n\n/**\n * __useDeleteEsopMutation__\n *\n * To run a mutation, you first call `useDeleteEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteEsopMutation, { data, loading, error }] = useDeleteEsopMutation({\n *   variables: {\n *      plan: // value for 'plan'\n *   },\n * });\n */\nexport function useDeleteEsopMutation(baseOptions?: Apollo.MutationHookOptions<DeleteEsopMutation, DeleteEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteEsopMutation, DeleteEsopMutationVariables>(DeleteEsopDocument, options);\n      }\nexport type DeleteEsopMutationHookResult = ReturnType<typeof useDeleteEsopMutation>;\nexport type DeleteEsopMutationResult = Apollo.MutationResult<DeleteEsopMutation>;\nexport type DeleteEsopMutationOptions = Apollo.BaseMutationOptions<DeleteEsopMutation, DeleteEsopMutationVariables>;\nexport const GetDataToLapseOfferEsopDocument: TypedDocumentNode<GetDataToLapseOfferEsopQuery, GetDataToLapseOfferEsopQueryVariables> = gql`\n  query getDataToLapseOfferESOP($offer: UUID!) {\n  lapseData: esopOffer(offerId: $offer) {\n    id\n    vestStartDate\n    softStatus\n    granted\n    vestablePeriodic\n    lapsed\n    lapsedPeriodic\n    exercised\n    vestedMilestone\n    lapsedMilestone\n    vestableMilestone\n    availableToPeriodicVest\n    availableToVestMilestone\n    availableToLapse\n    shareholder {\n      id\n      displayName\n    }\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        entryType\n      }\n    }\n    vestingEvents {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: esoptransactionSet {\n        id\n        transactionDate\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetDataToLapseOfferEsopQuery__\n *\n * To run a query within a React component, call `useGetDataToLapseOfferEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDataToLapseOfferEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDataToLapseOfferEsopQuery({\n *   variables: {\n *      offer: // value for 'offer'\n *   },\n * });\n */\nexport function useGetDataToLapseOfferEsopQuery(baseOptions: Apollo.QueryHookOptions<GetDataToLapseOfferEsopQuery, GetDataToLapseOfferEsopQueryVariables> & ({ variables: GetDataToLapseOfferEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDataToLapseOfferEsopQuery, GetDataToLapseOfferEsopQueryVariables>(GetDataToLapseOfferEsopDocument, options);\n      }\nexport function useGetDataToLapseOfferEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDataToLapseOfferEsopQuery, GetDataToLapseOfferEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDataToLapseOfferEsopQuery, GetDataToLapseOfferEsopQueryVariables>(GetDataToLapseOfferEsopDocument, options);\n        }\nexport function useGetDataToLapseOfferEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDataToLapseOfferEsopQuery, GetDataToLapseOfferEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDataToLapseOfferEsopQuery, GetDataToLapseOfferEsopQueryVariables>(GetDataToLapseOfferEsopDocument, options);\n        }\nexport type GetDataToLapseOfferEsopQueryHookResult = ReturnType<typeof useGetDataToLapseOfferEsopQuery>;\nexport type GetDataToLapseOfferEsopLazyQueryHookResult = ReturnType<typeof useGetDataToLapseOfferEsopLazyQuery>;\nexport type GetDataToLapseOfferEsopSuspenseQueryHookResult = ReturnType<typeof useGetDataToLapseOfferEsopSuspenseQuery>;\nexport type GetDataToLapseOfferEsopQueryResult = Apollo.QueryResult<GetDataToLapseOfferEsopQuery, GetDataToLapseOfferEsopQueryVariables>;\nexport function refetchGetDataToLapseOfferEsopQuery(variables: GetDataToLapseOfferEsopQueryVariables) {\n      return { query: GetDataToLapseOfferEsopDocument, variables: variables };\n    }\nexport const GetOffersEligibleForApprovalEsopDocument: TypedDocumentNode<GetOffersEligibleForApprovalEsopQuery, GetOffersEligibleForApprovalEsopQueryVariables> = gql`\n  query getOffersEligibleForApprovalESOP($esop: EsopCakeType!) {\n  esopOffersEligibleForApproval(esop: $esop) {\n    id\n    vestStartDate\n    shareholderDisplayName\n    vestingValue\n  }\n}\n    `;\n\n/**\n * __useGetOffersEligibleForApprovalEsopQuery__\n *\n * To run a query within a React component, call `useGetOffersEligibleForApprovalEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOffersEligibleForApprovalEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOffersEligibleForApprovalEsopQuery({\n *   variables: {\n *      esop: // value for 'esop'\n *   },\n * });\n */\nexport function useGetOffersEligibleForApprovalEsopQuery(baseOptions: Apollo.QueryHookOptions<GetOffersEligibleForApprovalEsopQuery, GetOffersEligibleForApprovalEsopQueryVariables> & ({ variables: GetOffersEligibleForApprovalEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOffersEligibleForApprovalEsopQuery, GetOffersEligibleForApprovalEsopQueryVariables>(GetOffersEligibleForApprovalEsopDocument, options);\n      }\nexport function useGetOffersEligibleForApprovalEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOffersEligibleForApprovalEsopQuery, GetOffersEligibleForApprovalEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOffersEligibleForApprovalEsopQuery, GetOffersEligibleForApprovalEsopQueryVariables>(GetOffersEligibleForApprovalEsopDocument, options);\n        }\nexport function useGetOffersEligibleForApprovalEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOffersEligibleForApprovalEsopQuery, GetOffersEligibleForApprovalEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOffersEligibleForApprovalEsopQuery, GetOffersEligibleForApprovalEsopQueryVariables>(GetOffersEligibleForApprovalEsopDocument, options);\n        }\nexport type GetOffersEligibleForApprovalEsopQueryHookResult = ReturnType<typeof useGetOffersEligibleForApprovalEsopQuery>;\nexport type GetOffersEligibleForApprovalEsopLazyQueryHookResult = ReturnType<typeof useGetOffersEligibleForApprovalEsopLazyQuery>;\nexport type GetOffersEligibleForApprovalEsopSuspenseQueryHookResult = ReturnType<typeof useGetOffersEligibleForApprovalEsopSuspenseQuery>;\nexport type GetOffersEligibleForApprovalEsopQueryResult = Apollo.QueryResult<GetOffersEligibleForApprovalEsopQuery, GetOffersEligibleForApprovalEsopQueryVariables>;\nexport function refetchGetOffersEligibleForApprovalEsopQuery(variables: GetOffersEligibleForApprovalEsopQueryVariables) {\n      return { query: GetOffersEligibleForApprovalEsopDocument, variables: variables };\n    }\nexport const LapseOfferMilestoneEsopDocument: TypedDocumentNode<LapseOfferMilestoneEsopMutation, LapseOfferMilestoneEsopMutationVariables> = gql`\n  mutation lapseOfferMilestoneESOP($offer: EsopOfferCakeType!, $lapseDate: Date!, $milestoneEvents: [LapseMilestoneEntryInputType!]!) {\n  lapseMilestoneEsop(\n    offer: $offer\n    lapseDate: $lapseDate\n    milestoneEvents: $milestoneEvents\n  )\n}\n    `;\nexport type LapseOfferMilestoneEsopMutationFn = Apollo.MutationFunction<LapseOfferMilestoneEsopMutation, LapseOfferMilestoneEsopMutationVariables>;\n\n/**\n * __useLapseOfferMilestoneEsopMutation__\n *\n * To run a mutation, you first call `useLapseOfferMilestoneEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useLapseOfferMilestoneEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [lapseOfferMilestoneEsopMutation, { data, loading, error }] = useLapseOfferMilestoneEsopMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      lapseDate: // value for 'lapseDate'\n *      milestoneEvents: // value for 'milestoneEvents'\n *   },\n * });\n */\nexport function useLapseOfferMilestoneEsopMutation(baseOptions?: Apollo.MutationHookOptions<LapseOfferMilestoneEsopMutation, LapseOfferMilestoneEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<LapseOfferMilestoneEsopMutation, LapseOfferMilestoneEsopMutationVariables>(LapseOfferMilestoneEsopDocument, options);\n      }\nexport type LapseOfferMilestoneEsopMutationHookResult = ReturnType<typeof useLapseOfferMilestoneEsopMutation>;\nexport type LapseOfferMilestoneEsopMutationResult = Apollo.MutationResult<LapseOfferMilestoneEsopMutation>;\nexport type LapseOfferMilestoneEsopMutationOptions = Apollo.BaseMutationOptions<LapseOfferMilestoneEsopMutation, LapseOfferMilestoneEsopMutationVariables>;\nexport const LapseOfferEsopDocument: TypedDocumentNode<LapseOfferEsopMutation, LapseOfferEsopMutationVariables> = gql`\n  mutation lapseOfferESOP($offer: EsopOfferCakeType!, $lapseDate: Date!, $acceleratedValue: PositiveIntegerOrZero!) {\n  lapseOfferEsop(\n    offer: $offer\n    lapseDate: $lapseDate\n    acceleratedValue: $acceleratedValue\n  )\n}\n    `;\nexport type LapseOfferEsopMutationFn = Apollo.MutationFunction<LapseOfferEsopMutation, LapseOfferEsopMutationVariables>;\n\n/**\n * __useLapseOfferEsopMutation__\n *\n * To run a mutation, you first call `useLapseOfferEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useLapseOfferEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [lapseOfferEsopMutation, { data, loading, error }] = useLapseOfferEsopMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      lapseDate: // value for 'lapseDate'\n *      acceleratedValue: // value for 'acceleratedValue'\n *   },\n * });\n */\nexport function useLapseOfferEsopMutation(baseOptions?: Apollo.MutationHookOptions<LapseOfferEsopMutation, LapseOfferEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<LapseOfferEsopMutation, LapseOfferEsopMutationVariables>(LapseOfferEsopDocument, options);\n      }\nexport type LapseOfferEsopMutationHookResult = ReturnType<typeof useLapseOfferEsopMutation>;\nexport type LapseOfferEsopMutationResult = Apollo.MutationResult<LapseOfferEsopMutation>;\nexport type LapseOfferEsopMutationOptions = Apollo.BaseMutationOptions<LapseOfferEsopMutation, LapseOfferEsopMutationVariables>;\nexport const FullyLapseOfferEsopDocument: TypedDocumentNode<FullyLapseOfferEsopMutation, FullyLapseOfferEsopMutationVariables> = gql`\n  mutation fullyLapseOfferESOP($offer: EsopOfferCakeType!, $transactionDate: Date!, $acceleratedValue: PositiveIntegerOrZero!) {\n  fullyLapseOfferEsop(\n    offer: $offer\n    transactionDate: $transactionDate\n    acceleratedValue: $acceleratedValue\n  )\n}\n    `;\nexport type FullyLapseOfferEsopMutationFn = Apollo.MutationFunction<FullyLapseOfferEsopMutation, FullyLapseOfferEsopMutationVariables>;\n\n/**\n * __useFullyLapseOfferEsopMutation__\n *\n * To run a mutation, you first call `useFullyLapseOfferEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useFullyLapseOfferEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [fullyLapseOfferEsopMutation, { data, loading, error }] = useFullyLapseOfferEsopMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      transactionDate: // value for 'transactionDate'\n *      acceleratedValue: // value for 'acceleratedValue'\n *   },\n * });\n */\nexport function useFullyLapseOfferEsopMutation(baseOptions?: Apollo.MutationHookOptions<FullyLapseOfferEsopMutation, FullyLapseOfferEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<FullyLapseOfferEsopMutation, FullyLapseOfferEsopMutationVariables>(FullyLapseOfferEsopDocument, options);\n      }\nexport type FullyLapseOfferEsopMutationHookResult = ReturnType<typeof useFullyLapseOfferEsopMutation>;\nexport type FullyLapseOfferEsopMutationResult = Apollo.MutationResult<FullyLapseOfferEsopMutation>;\nexport type FullyLapseOfferEsopMutationOptions = Apollo.BaseMutationOptions<FullyLapseOfferEsopMutation, FullyLapseOfferEsopMutationVariables>;\nexport const AssignBareTrustEsopDocument: TypedDocumentNode<AssignBareTrustEsopMutation, AssignBareTrustEsopMutationVariables> = gql`\n  mutation assignBareTrustEsop($offers: EsopOfferQuerySetCakeType!, $bareTrustTrustee: ShareholderCakeType) {\n  assignBareTrustEsop(offers: $offers, bareTrustTrustee: $bareTrustTrustee)\n}\n    `;\nexport type AssignBareTrustEsopMutationFn = Apollo.MutationFunction<AssignBareTrustEsopMutation, AssignBareTrustEsopMutationVariables>;\n\n/**\n * __useAssignBareTrustEsopMutation__\n *\n * To run a mutation, you first call `useAssignBareTrustEsopMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAssignBareTrustEsopMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [assignBareTrustEsopMutation, { data, loading, error }] = useAssignBareTrustEsopMutation({\n *   variables: {\n *      offers: // value for 'offers'\n *      bareTrustTrustee: // value for 'bareTrustTrustee'\n *   },\n * });\n */\nexport function useAssignBareTrustEsopMutation(baseOptions?: Apollo.MutationHookOptions<AssignBareTrustEsopMutation, AssignBareTrustEsopMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AssignBareTrustEsopMutation, AssignBareTrustEsopMutationVariables>(AssignBareTrustEsopDocument, options);\n      }\nexport type AssignBareTrustEsopMutationHookResult = ReturnType<typeof useAssignBareTrustEsopMutation>;\nexport type AssignBareTrustEsopMutationResult = Apollo.MutationResult<AssignBareTrustEsopMutation>;\nexport type AssignBareTrustEsopMutationOptions = Apollo.BaseMutationOptions<AssignBareTrustEsopMutation, AssignBareTrustEsopMutationVariables>;\nexport const GetPlansEsopDocument: TypedDocumentNode<GetPlansEsopQuery, GetPlansEsopQueryVariables> = gql`\n  query getPlansESOP($organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  plans: esops(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    id\n    name\n    vestingValue\n    totalExercised\n    totalVested\n    totalLapsed\n    totalOffered\n    group: offerGroup {\n      country\n    }\n  }\n  organisation(organisationId: $organisationId) {\n    fullyDilutedShares\n  }\n}\n    `;\n\n/**\n * __useGetPlansEsopQuery__\n *\n * To run a query within a React component, call `useGetPlansEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlansEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlansEsopQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetPlansEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlansEsopQuery, GetPlansEsopQueryVariables> & ({ variables: GetPlansEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlansEsopQuery, GetPlansEsopQueryVariables>(GetPlansEsopDocument, options);\n      }\nexport function useGetPlansEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlansEsopQuery, GetPlansEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlansEsopQuery, GetPlansEsopQueryVariables>(GetPlansEsopDocument, options);\n        }\nexport function useGetPlansEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlansEsopQuery, GetPlansEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlansEsopQuery, GetPlansEsopQueryVariables>(GetPlansEsopDocument, options);\n        }\nexport type GetPlansEsopQueryHookResult = ReturnType<typeof useGetPlansEsopQuery>;\nexport type GetPlansEsopLazyQueryHookResult = ReturnType<typeof useGetPlansEsopLazyQuery>;\nexport type GetPlansEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlansEsopSuspenseQuery>;\nexport type GetPlansEsopQueryResult = Apollo.QueryResult<GetPlansEsopQuery, GetPlansEsopQueryVariables>;\nexport function refetchGetPlansEsopQuery(variables: GetPlansEsopQueryVariables) {\n      return { query: GetPlansEsopDocument, variables: variables };\n    }\nexport const GetPlanEsopDocument: TypedDocumentNode<GetPlanEsopQuery, GetPlanEsopQueryVariables> = gql`\n  query getPlanESOP($organisationId: UUID!, $esopId: UUID!) {\n  plan: esops(organisationId: $organisationId, filterPlan: $esopId) {\n    id\n    name\n    vestingValue\n    commentCount\n    optionPrice\n    requireWitness\n    totalVested\n    totalExercised\n    totalLapsed\n    totalGranted\n    totalOffered\n    organisation {\n      id\n      created\n      fullyDilutedShares\n      country\n      currency\n      valuationAt {\n        valuation\n      }\n    }\n    documents {\n      id\n      created\n      name\n      file\n      extension\n    }\n    group: offerGroup {\n      id\n      country\n      sharetype {\n        id\n        name\n        symbol\n      }\n      offerCount\n      offerAcceptedCount\n      defaultPlanRulesTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      defaultOfferLetterTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      planRulesTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      offerLetterTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      directorsResolution {\n        id\n        name\n        contractType\n        created\n        type\n        signatures {\n          name\n          email\n          status\n          extra\n        }\n      }\n      directorsResolutionTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      shareholdersResolution {\n        id\n        name\n        contractType\n        created\n        type\n        signatures {\n          name\n          email\n          status\n          extra\n        }\n      }\n      shareholdersResolutionTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanEsopQuery__\n *\n * To run a query within a React component, call `useGetPlanEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanEsopQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      esopId: // value for 'esopId'\n *   },\n * });\n */\nexport function useGetPlanEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlanEsopQuery, GetPlanEsopQueryVariables> & ({ variables: GetPlanEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanEsopQuery, GetPlanEsopQueryVariables>(GetPlanEsopDocument, options);\n      }\nexport function useGetPlanEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanEsopQuery, GetPlanEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanEsopQuery, GetPlanEsopQueryVariables>(GetPlanEsopDocument, options);\n        }\nexport function useGetPlanEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanEsopQuery, GetPlanEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanEsopQuery, GetPlanEsopQueryVariables>(GetPlanEsopDocument, options);\n        }\nexport type GetPlanEsopQueryHookResult = ReturnType<typeof useGetPlanEsopQuery>;\nexport type GetPlanEsopLazyQueryHookResult = ReturnType<typeof useGetPlanEsopLazyQuery>;\nexport type GetPlanEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlanEsopSuspenseQuery>;\nexport type GetPlanEsopQueryResult = Apollo.QueryResult<GetPlanEsopQuery, GetPlanEsopQueryVariables>;\nexport function refetchGetPlanEsopQuery(variables: GetPlanEsopQueryVariables) {\n      return { query: GetPlanEsopDocument, variables: variables };\n    }\nexport const GetPlanGroupEsopDocument: TypedDocumentNode<GetPlanGroupEsopQuery, GetPlanGroupEsopQueryVariables> = gql`\n  query getPlanGroupESOP($groupId: EsopOfferGroupCakeType!) {\n  group: esopOfferGroup(group: $groupId) {\n    id\n    country\n    optionPrice\n    exercisePrice\n    exerciseExpireTime {\n      quantity\n      unit\n    }\n    valueOfClassOfShare\n    restrictionsOnShares\n    totalGranted\n    totalVested\n    totalLapsed\n    totalExercised\n    totalOffered\n    offerCount\n    offerAcceptedCount\n    allowNomineeTrust\n    offerLetterTemplate {\n      id\n      name\n      contractType\n      status\n      modified\n    }\n    planRulesTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n      modified\n    }\n    shareholdersResolutionTemplate {\n      id\n      name\n      contractType\n      status\n      modified\n    }\n    shareholdersResolution {\n      id\n      name\n      contractType\n      signatures {\n        name\n        email\n        status\n        extra\n      }\n    }\n    directorsResolutionTemplate {\n      id\n      name\n      contractType\n      status\n      modified\n    }\n    directorsResolution {\n      id\n      name\n      contractType\n      signatures {\n        name\n        email\n        status\n        extra\n      }\n    }\n    plan {\n      id\n      name\n    }\n    sharetype {\n      id\n      name\n      symbol\n    }\n    disclosurePeriodDays\n    isEditable\n    currency\n    groupCurrency\n  }\n}\n    `;\n\n/**\n * __useGetPlanGroupEsopQuery__\n *\n * To run a query within a React component, call `useGetPlanGroupEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanGroupEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanGroupEsopQuery({\n *   variables: {\n *      groupId: // value for 'groupId'\n *   },\n * });\n */\nexport function useGetPlanGroupEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlanGroupEsopQuery, GetPlanGroupEsopQueryVariables> & ({ variables: GetPlanGroupEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanGroupEsopQuery, GetPlanGroupEsopQueryVariables>(GetPlanGroupEsopDocument, options);\n      }\nexport function useGetPlanGroupEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanGroupEsopQuery, GetPlanGroupEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanGroupEsopQuery, GetPlanGroupEsopQueryVariables>(GetPlanGroupEsopDocument, options);\n        }\nexport function useGetPlanGroupEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanGroupEsopQuery, GetPlanGroupEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanGroupEsopQuery, GetPlanGroupEsopQueryVariables>(GetPlanGroupEsopDocument, options);\n        }\nexport type GetPlanGroupEsopQueryHookResult = ReturnType<typeof useGetPlanGroupEsopQuery>;\nexport type GetPlanGroupEsopLazyQueryHookResult = ReturnType<typeof useGetPlanGroupEsopLazyQuery>;\nexport type GetPlanGroupEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlanGroupEsopSuspenseQuery>;\nexport type GetPlanGroupEsopQueryResult = Apollo.QueryResult<GetPlanGroupEsopQuery, GetPlanGroupEsopQueryVariables>;\nexport function refetchGetPlanGroupEsopQuery(variables: GetPlanGroupEsopQueryVariables) {\n      return { query: GetPlanGroupEsopDocument, variables: variables };\n    }\nexport const GetPlanOffersToCompleteEsopDocument: TypedDocumentNode<GetPlanOffersToCompleteEsopQuery, GetPlanOffersToCompleteEsopQueryVariables> = gql`\n  query getPlanOffersToCompleteESOP($organisationId: UUID!, $offerIds: [UUID]!) {\n  offers: esopOffersToComplete(\n    organisationId: $organisationId\n    offerIds: $offerIds\n  ) {\n    id\n    vestStartDate\n    country\n    exercisePrice\n    status\n    softStatus\n    optionType\n    shareholderDisplayName\n    shareholder: shareholderOpt {\n      id\n      secondaryName\n      avatar\n      recipient {\n        id\n        displayName\n      }\n      investorData {\n        name\n        email\n        jointIndex\n        companyData {\n          signers {\n            name\n            email\n          }\n        }\n      }\n    }\n    offerLetterTemplate {\n      id\n    }\n    group {\n      id\n      country\n      restrictionsOnShares\n      allowNomineeTrust\n      offerLetterTemplate {\n        id\n        name\n        status\n        contractType\n        modified\n      }\n      planRulesTemplate {\n        id\n        name\n        status\n        type\n        contractType\n        modified\n        extension\n      }\n      defaultPlanRulesTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      defaultOfferLetterTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      currency\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOffersToCompleteEsopQuery__\n *\n * To run a query within a React component, call `useGetPlanOffersToCompleteEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOffersToCompleteEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOffersToCompleteEsopQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      offerIds: // value for 'offerIds'\n *   },\n * });\n */\nexport function useGetPlanOffersToCompleteEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOffersToCompleteEsopQuery, GetPlanOffersToCompleteEsopQueryVariables> & ({ variables: GetPlanOffersToCompleteEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOffersToCompleteEsopQuery, GetPlanOffersToCompleteEsopQueryVariables>(GetPlanOffersToCompleteEsopDocument, options);\n      }\nexport function useGetPlanOffersToCompleteEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOffersToCompleteEsopQuery, GetPlanOffersToCompleteEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOffersToCompleteEsopQuery, GetPlanOffersToCompleteEsopQueryVariables>(GetPlanOffersToCompleteEsopDocument, options);\n        }\nexport function useGetPlanOffersToCompleteEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOffersToCompleteEsopQuery, GetPlanOffersToCompleteEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOffersToCompleteEsopQuery, GetPlanOffersToCompleteEsopQueryVariables>(GetPlanOffersToCompleteEsopDocument, options);\n        }\nexport type GetPlanOffersToCompleteEsopQueryHookResult = ReturnType<typeof useGetPlanOffersToCompleteEsopQuery>;\nexport type GetPlanOffersToCompleteEsopLazyQueryHookResult = ReturnType<typeof useGetPlanOffersToCompleteEsopLazyQuery>;\nexport type GetPlanOffersToCompleteEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlanOffersToCompleteEsopSuspenseQuery>;\nexport type GetPlanOffersToCompleteEsopQueryResult = Apollo.QueryResult<GetPlanOffersToCompleteEsopQuery, GetPlanOffersToCompleteEsopQueryVariables>;\nexport function refetchGetPlanOffersToCompleteEsopQuery(variables: GetPlanOffersToCompleteEsopQueryVariables) {\n      return { query: GetPlanOffersToCompleteEsopDocument, variables: variables };\n    }\nexport const GetPlanOffersEsopDocument: TypedDocumentNode<GetPlanOffersEsopQuery, GetPlanOffersEsopQueryVariables> = gql`\n  query getPlanOffersESOP($organisationId: UUID!, $filterId: UUID!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $filters: [ListFilterType!], $sort: [CleanString!], $search: String) {\n  offers: optionPoolOffers(\n    organisationId: $organisationId\n    filterId: $filterId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    filters: $filters\n    sort: $sort\n    search: $search\n  ) {\n    plan {\n      id\n      vestingValue\n      totalOffered\n      totalLapsed\n      organisation {\n        fullyDilutedShares\n      }\n    }\n    count\n    currentPage\n    notSignedUpCount\n    shareholderCount\n    pageData {\n      id\n      modified\n      groupId\n      planId\n      offerLetterId\n      boardApprovalId\n      dateGranted\n      vestStartDate\n      emailsOn\n      requireWitness\n      shareholderId\n      shareholderDisplayName\n      shareholderSecondaryName\n      shareholderAvatar\n      shareholderHasLoggedIn\n      shareholderConsideredInvited\n      shEmail\n      stakeholderType: shareholderType\n      isTrust: shareholderIsTrust\n      status\n      softStatus\n      country\n      vestingValue\n      availableToLapse\n      availableToExercise\n      availableToVest\n      vested\n      granted\n      lapsed\n      exercised\n      hasOngoingPauseEvents\n      hasScheduledPauseEvents\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOffersEsopQuery__\n *\n * To run a query within a React component, call `useGetPlanOffersEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOffersEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOffersEsopQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      filterId: // value for 'filterId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      filters: // value for 'filters'\n *      sort: // value for 'sort'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetPlanOffersEsopQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOffersEsopQuery, GetPlanOffersEsopQueryVariables> & ({ variables: GetPlanOffersEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOffersEsopQuery, GetPlanOffersEsopQueryVariables>(GetPlanOffersEsopDocument, options);\n      }\nexport function useGetPlanOffersEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOffersEsopQuery, GetPlanOffersEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOffersEsopQuery, GetPlanOffersEsopQueryVariables>(GetPlanOffersEsopDocument, options);\n        }\nexport function useGetPlanOffersEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOffersEsopQuery, GetPlanOffersEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOffersEsopQuery, GetPlanOffersEsopQueryVariables>(GetPlanOffersEsopDocument, options);\n        }\nexport type GetPlanOffersEsopQueryHookResult = ReturnType<typeof useGetPlanOffersEsopQuery>;\nexport type GetPlanOffersEsopLazyQueryHookResult = ReturnType<typeof useGetPlanOffersEsopLazyQuery>;\nexport type GetPlanOffersEsopSuspenseQueryHookResult = ReturnType<typeof useGetPlanOffersEsopSuspenseQuery>;\nexport type GetPlanOffersEsopQueryResult = Apollo.QueryResult<GetPlanOffersEsopQuery, GetPlanOffersEsopQueryVariables>;\nexport function refetchGetPlanOffersEsopQuery(variables: GetPlanOffersEsopQueryVariables) {\n      return { query: GetPlanOffersEsopDocument, variables: variables };\n    }\nexport const OffersVestingEventsEsopDocument: TypedDocumentNode<OffersVestingEventsEsopQuery, OffersVestingEventsEsopQueryVariables> = gql`\n  query offersVestingEventsESOP($offerIds: [UUID!]!) {\n  optionPoolOffersVestingEvents(offerIds: $offerIds) {\n    id\n    offerId\n    order\n    vestingValue\n    eventType\n    vestingData {\n      description\n      duration {\n        value\n        granularity\n      }\n      frequency {\n        value\n        granularity\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useOffersVestingEventsEsopQuery__\n *\n * To run a query within a React component, call `useOffersVestingEventsEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffersVestingEventsEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffersVestingEventsEsopQuery({\n *   variables: {\n *      offerIds: // value for 'offerIds'\n *   },\n * });\n */\nexport function useOffersVestingEventsEsopQuery(baseOptions: Apollo.QueryHookOptions<OffersVestingEventsEsopQuery, OffersVestingEventsEsopQueryVariables> & ({ variables: OffersVestingEventsEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffersVestingEventsEsopQuery, OffersVestingEventsEsopQueryVariables>(OffersVestingEventsEsopDocument, options);\n      }\nexport function useOffersVestingEventsEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffersVestingEventsEsopQuery, OffersVestingEventsEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffersVestingEventsEsopQuery, OffersVestingEventsEsopQueryVariables>(OffersVestingEventsEsopDocument, options);\n        }\nexport function useOffersVestingEventsEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffersVestingEventsEsopQuery, OffersVestingEventsEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffersVestingEventsEsopQuery, OffersVestingEventsEsopQueryVariables>(OffersVestingEventsEsopDocument, options);\n        }\nexport type OffersVestingEventsEsopQueryHookResult = ReturnType<typeof useOffersVestingEventsEsopQuery>;\nexport type OffersVestingEventsEsopLazyQueryHookResult = ReturnType<typeof useOffersVestingEventsEsopLazyQuery>;\nexport type OffersVestingEventsEsopSuspenseQueryHookResult = ReturnType<typeof useOffersVestingEventsEsopSuspenseQuery>;\nexport type OffersVestingEventsEsopQueryResult = Apollo.QueryResult<OffersVestingEventsEsopQuery, OffersVestingEventsEsopQueryVariables>;\nexport function refetchOffersVestingEventsEsopQuery(variables: OffersVestingEventsEsopQueryVariables) {\n      return { query: OffersVestingEventsEsopDocument, variables: variables };\n    }\nexport const OffersVestingEventsEsop2Document: TypedDocumentNode<OffersVestingEventsEsop2Query, OffersVestingEventsEsop2QueryVariables> = gql`\n  query offersVestingEventsESOP2($offerIds: [UUID!]!) {\n  offersVestingEvents: optionPoolOffersVestingEvents(offerIds: $offerIds) {\n    id\n    offerId\n    order\n    vestingValue\n    eventType\n    vestingData {\n      description\n      duration {\n        value\n        granularity\n      }\n      frequency {\n        value\n        granularity\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useOffersVestingEventsEsop2Query__\n *\n * To run a query within a React component, call `useOffersVestingEventsEsop2Query` and pass it any options that fit your needs.\n * When your component renders, `useOffersVestingEventsEsop2Query` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffersVestingEventsEsop2Query({\n *   variables: {\n *      offerIds: // value for 'offerIds'\n *   },\n * });\n */\nexport function useOffersVestingEventsEsop2Query(baseOptions: Apollo.QueryHookOptions<OffersVestingEventsEsop2Query, OffersVestingEventsEsop2QueryVariables> & ({ variables: OffersVestingEventsEsop2QueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffersVestingEventsEsop2Query, OffersVestingEventsEsop2QueryVariables>(OffersVestingEventsEsop2Document, options);\n      }\nexport function useOffersVestingEventsEsop2LazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffersVestingEventsEsop2Query, OffersVestingEventsEsop2QueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffersVestingEventsEsop2Query, OffersVestingEventsEsop2QueryVariables>(OffersVestingEventsEsop2Document, options);\n        }\nexport function useOffersVestingEventsEsop2SuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffersVestingEventsEsop2Query, OffersVestingEventsEsop2QueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffersVestingEventsEsop2Query, OffersVestingEventsEsop2QueryVariables>(OffersVestingEventsEsop2Document, options);\n        }\nexport type OffersVestingEventsEsop2QueryHookResult = ReturnType<typeof useOffersVestingEventsEsop2Query>;\nexport type OffersVestingEventsEsop2LazyQueryHookResult = ReturnType<typeof useOffersVestingEventsEsop2LazyQuery>;\nexport type OffersVestingEventsEsop2SuspenseQueryHookResult = ReturnType<typeof useOffersVestingEventsEsop2SuspenseQuery>;\nexport type OffersVestingEventsEsop2QueryResult = Apollo.QueryResult<OffersVestingEventsEsop2Query, OffersVestingEventsEsop2QueryVariables>;\nexport function refetchOffersVestingEventsEsop2Query(variables: OffersVestingEventsEsop2QueryVariables) {\n      return { query: OffersVestingEventsEsop2Document, variables: variables };\n    }\nexport const GetPlanToEditEssDocument: TypedDocumentNode<GetPlanToEditEssQuery, GetPlanToEditEssQueryVariables> = gql`\n  query getPlanToEditESS($organisationId: UUID!, $planId: UUID!) {\n  plan: esss(organisationId: $organisationId, filterPlan: $planId) {\n    id\n    name\n    vestingValue\n    requireWitness\n    totalVested\n    totalLapsed\n    totalGranted\n    totalOffered\n    group: offerGroup {\n      id\n      country\n      sharetype {\n        id\n        name\n        symbol\n      }\n      isEditable\n      totalOffered\n      totalGranted\n      totalVested\n      totalLapsed\n      totalExercised\n      allowNomineeTrust\n      requireBoardApproval\n      loanFunded\n    }\n  }\n  sharetypes(organisationId: $organisationId) {\n    id\n    name\n    symbol\n  }\n}\n    `;\n\n/**\n * __useGetPlanToEditEssQuery__\n *\n * To run a query within a React component, call `useGetPlanToEditEssQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanToEditEssQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanToEditEssQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      planId: // value for 'planId'\n *   },\n * });\n */\nexport function useGetPlanToEditEssQuery(baseOptions: Apollo.QueryHookOptions<GetPlanToEditEssQuery, GetPlanToEditEssQueryVariables> & ({ variables: GetPlanToEditEssQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanToEditEssQuery, GetPlanToEditEssQueryVariables>(GetPlanToEditEssDocument, options);\n      }\nexport function useGetPlanToEditEssLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanToEditEssQuery, GetPlanToEditEssQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanToEditEssQuery, GetPlanToEditEssQueryVariables>(GetPlanToEditEssDocument, options);\n        }\nexport function useGetPlanToEditEssSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanToEditEssQuery, GetPlanToEditEssQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanToEditEssQuery, GetPlanToEditEssQueryVariables>(GetPlanToEditEssDocument, options);\n        }\nexport type GetPlanToEditEssQueryHookResult = ReturnType<typeof useGetPlanToEditEssQuery>;\nexport type GetPlanToEditEssLazyQueryHookResult = ReturnType<typeof useGetPlanToEditEssLazyQuery>;\nexport type GetPlanToEditEssSuspenseQueryHookResult = ReturnType<typeof useGetPlanToEditEssSuspenseQuery>;\nexport type GetPlanToEditEssQueryResult = Apollo.QueryResult<GetPlanToEditEssQuery, GetPlanToEditEssQueryVariables>;\nexport function refetchGetPlanToEditEssQuery(variables: GetPlanToEditEssQueryVariables) {\n      return { query: GetPlanToEditEssDocument, variables: variables };\n    }\nexport const EditEssDocument: TypedDocumentNode<EditEssMutation, EditEssMutationVariables> = gql`\n  mutation editESS($plan: EssCakeType!, $name: CleanString, $vestingValue: PositiveInteger, $requireWitness: Boolean) {\n  editEss(\n    plan: $plan\n    name: $name\n    vestingValue: $vestingValue\n    requireWitness: $requireWitness\n  )\n}\n    `;\nexport type EditEssMutationFn = Apollo.MutationFunction<EditEssMutation, EditEssMutationVariables>;\n\n/**\n * __useEditEssMutation__\n *\n * To run a mutation, you first call `useEditEssMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditEssMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editEssMutation, { data, loading, error }] = useEditEssMutation({\n *   variables: {\n *      plan: // value for 'plan'\n *      name: // value for 'name'\n *      vestingValue: // value for 'vestingValue'\n *      requireWitness: // value for 'requireWitness'\n *   },\n * });\n */\nexport function useEditEssMutation(baseOptions?: Apollo.MutationHookOptions<EditEssMutation, EditEssMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditEssMutation, EditEssMutationVariables>(EditEssDocument, options);\n      }\nexport type EditEssMutationHookResult = ReturnType<typeof useEditEssMutation>;\nexport type EditEssMutationResult = Apollo.MutationResult<EditEssMutation>;\nexport type EditEssMutationOptions = Apollo.BaseMutationOptions<EditEssMutation, EditEssMutationVariables>;\nexport const EditGroupAndEssDocument: TypedDocumentNode<EditGroupAndEssMutation, EditGroupAndEssMutationVariables> = gql`\n  mutation editGroupAndESS($plan: EssCakeType!, $name: CleanString, $vestingValue: PositiveInteger, $group: EssOfferGroupCakeType!, $sharetype: SharetypeCakeType, $allowNomineeTrust: Boolean, $requireBoardApproval: Boolean, $enforceDisclosurePeriod: Boolean, $requireWitness: Boolean, $loanFunded: Boolean) {\n  editEss(\n    plan: $plan\n    name: $name\n    vestingValue: $vestingValue\n    requireWitness: $requireWitness\n  )\n  editGroupEss(\n    group: $group\n    sharetype: $sharetype\n    allowNomineeTrust: $allowNomineeTrust\n    requireBoardApproval: $requireBoardApproval\n    enforceDisclosurePeriod: $enforceDisclosurePeriod\n    loanFunded: $loanFunded\n  )\n}\n    `;\nexport type EditGroupAndEssMutationFn = Apollo.MutationFunction<EditGroupAndEssMutation, EditGroupAndEssMutationVariables>;\n\n/**\n * __useEditGroupAndEssMutation__\n *\n * To run a mutation, you first call `useEditGroupAndEssMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditGroupAndEssMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editGroupAndEssMutation, { data, loading, error }] = useEditGroupAndEssMutation({\n *   variables: {\n *      plan: // value for 'plan'\n *      name: // value for 'name'\n *      vestingValue: // value for 'vestingValue'\n *      group: // value for 'group'\n *      sharetype: // value for 'sharetype'\n *      allowNomineeTrust: // value for 'allowNomineeTrust'\n *      requireBoardApproval: // value for 'requireBoardApproval'\n *      enforceDisclosurePeriod: // value for 'enforceDisclosurePeriod'\n *      requireWitness: // value for 'requireWitness'\n *      loanFunded: // value for 'loanFunded'\n *   },\n * });\n */\nexport function useEditGroupAndEssMutation(baseOptions?: Apollo.MutationHookOptions<EditGroupAndEssMutation, EditGroupAndEssMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditGroupAndEssMutation, EditGroupAndEssMutationVariables>(EditGroupAndEssDocument, options);\n      }\nexport type EditGroupAndEssMutationHookResult = ReturnType<typeof useEditGroupAndEssMutation>;\nexport type EditGroupAndEssMutationResult = Apollo.MutationResult<EditGroupAndEssMutation>;\nexport type EditGroupAndEssMutationOptions = Apollo.BaseMutationOptions<EditGroupAndEssMutation, EditGroupAndEssMutationVariables>;\nexport const DeleteEssDocument: TypedDocumentNode<DeleteEssMutation, DeleteEssMutationVariables> = gql`\n  mutation deleteESS($plan: EssCakeType!) {\n  deleteEss(plan: $plan)\n}\n    `;\nexport type DeleteEssMutationFn = Apollo.MutationFunction<DeleteEssMutation, DeleteEssMutationVariables>;\n\n/**\n * __useDeleteEssMutation__\n *\n * To run a mutation, you first call `useDeleteEssMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteEssMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteEssMutation, { data, loading, error }] = useDeleteEssMutation({\n *   variables: {\n *      plan: // value for 'plan'\n *   },\n * });\n */\nexport function useDeleteEssMutation(baseOptions?: Apollo.MutationHookOptions<DeleteEssMutation, DeleteEssMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteEssMutation, DeleteEssMutationVariables>(DeleteEssDocument, options);\n      }\nexport type DeleteEssMutationHookResult = ReturnType<typeof useDeleteEssMutation>;\nexport type DeleteEssMutationResult = Apollo.MutationResult<DeleteEssMutation>;\nexport type DeleteEssMutationOptions = Apollo.BaseMutationOptions<DeleteEssMutation, DeleteEssMutationVariables>;\nexport const GetPlansEssDocument: TypedDocumentNode<GetPlansEssQuery, GetPlansEssQueryVariables> = gql`\n  query getPlansESS($organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  plans: esss(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    id\n    name\n    vestingValue\n    percentageOfOrganisationShares\n    totalVested\n    totalLapsed\n    totalOffered\n    group: offerGroup {\n      country\n    }\n  }\n  organisation(organisationId: $organisationId) {\n    fullyDilutedShares\n  }\n}\n    `;\n\n/**\n * __useGetPlansEssQuery__\n *\n * To run a query within a React component, call `useGetPlansEssQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlansEssQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlansEssQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetPlansEssQuery(baseOptions: Apollo.QueryHookOptions<GetPlansEssQuery, GetPlansEssQueryVariables> & ({ variables: GetPlansEssQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlansEssQuery, GetPlansEssQueryVariables>(GetPlansEssDocument, options);\n      }\nexport function useGetPlansEssLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlansEssQuery, GetPlansEssQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlansEssQuery, GetPlansEssQueryVariables>(GetPlansEssDocument, options);\n        }\nexport function useGetPlansEssSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlansEssQuery, GetPlansEssQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlansEssQuery, GetPlansEssQueryVariables>(GetPlansEssDocument, options);\n        }\nexport type GetPlansEssQueryHookResult = ReturnType<typeof useGetPlansEssQuery>;\nexport type GetPlansEssLazyQueryHookResult = ReturnType<typeof useGetPlansEssLazyQuery>;\nexport type GetPlansEssSuspenseQueryHookResult = ReturnType<typeof useGetPlansEssSuspenseQuery>;\nexport type GetPlansEssQueryResult = Apollo.QueryResult<GetPlansEssQuery, GetPlansEssQueryVariables>;\nexport function refetchGetPlansEssQuery(variables: GetPlansEssQueryVariables) {\n      return { query: GetPlansEssDocument, variables: variables };\n    }\nexport const GetPlanNamesEssDocument: TypedDocumentNode<GetPlanNamesEssQuery, GetPlanNamesEssQueryVariables> = gql`\n  query getPlanNamesESS($organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  esss(organisationId: $organisationId, page: $page, itemsPerPage: $itemsPerPage) {\n    id\n    name\n  }\n}\n    `;\n\n/**\n * __useGetPlanNamesEssQuery__\n *\n * To run a query within a React component, call `useGetPlanNamesEssQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanNamesEssQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanNamesEssQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetPlanNamesEssQuery(baseOptions: Apollo.QueryHookOptions<GetPlanNamesEssQuery, GetPlanNamesEssQueryVariables> & ({ variables: GetPlanNamesEssQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanNamesEssQuery, GetPlanNamesEssQueryVariables>(GetPlanNamesEssDocument, options);\n      }\nexport function useGetPlanNamesEssLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanNamesEssQuery, GetPlanNamesEssQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanNamesEssQuery, GetPlanNamesEssQueryVariables>(GetPlanNamesEssDocument, options);\n        }\nexport function useGetPlanNamesEssSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanNamesEssQuery, GetPlanNamesEssQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanNamesEssQuery, GetPlanNamesEssQueryVariables>(GetPlanNamesEssDocument, options);\n        }\nexport type GetPlanNamesEssQueryHookResult = ReturnType<typeof useGetPlanNamesEssQuery>;\nexport type GetPlanNamesEssLazyQueryHookResult = ReturnType<typeof useGetPlanNamesEssLazyQuery>;\nexport type GetPlanNamesEssSuspenseQueryHookResult = ReturnType<typeof useGetPlanNamesEssSuspenseQuery>;\nexport type GetPlanNamesEssQueryResult = Apollo.QueryResult<GetPlanNamesEssQuery, GetPlanNamesEssQueryVariables>;\nexport function refetchGetPlanNamesEssQuery(variables: GetPlanNamesEssQueryVariables) {\n      return { query: GetPlanNamesEssDocument, variables: variables };\n    }\nexport const GetSharePlanDocument: TypedDocumentNode<GetSharePlanQuery, GetSharePlanQueryVariables> = gql`\n  query getSharePlan($organisationId: UUID!, $essId: UUID!) {\n  plan: esss(organisationId: $organisationId, filterPlan: $essId) {\n    id\n    name\n    vestingValue\n    commentCount\n    requireWitness\n    totalVested\n    totalLapsed\n    totalGranted\n    totalOffered\n    organisation {\n      id\n      created\n      fullyDilutedShares\n      country\n      currency\n      valuationAt {\n        valuation\n      }\n    }\n    documents {\n      id\n      created\n      name\n      file\n      extension\n    }\n    group: offerGroup {\n      id\n      country\n      sharetype {\n        id\n        name\n        symbol\n      }\n      offerCount\n      offerAcceptedCount\n      defaultPlanRulesTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      defaultOfferLetterTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      planRulesTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      offerLetterTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetSharePlanQuery__\n *\n * To run a query within a React component, call `useGetSharePlanQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetSharePlanQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetSharePlanQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      essId: // value for 'essId'\n *   },\n * });\n */\nexport function useGetSharePlanQuery(baseOptions: Apollo.QueryHookOptions<GetSharePlanQuery, GetSharePlanQueryVariables> & ({ variables: GetSharePlanQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetSharePlanQuery, GetSharePlanQueryVariables>(GetSharePlanDocument, options);\n      }\nexport function useGetSharePlanLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetSharePlanQuery, GetSharePlanQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetSharePlanQuery, GetSharePlanQueryVariables>(GetSharePlanDocument, options);\n        }\nexport function useGetSharePlanSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetSharePlanQuery, GetSharePlanQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetSharePlanQuery, GetSharePlanQueryVariables>(GetSharePlanDocument, options);\n        }\nexport type GetSharePlanQueryHookResult = ReturnType<typeof useGetSharePlanQuery>;\nexport type GetSharePlanLazyQueryHookResult = ReturnType<typeof useGetSharePlanLazyQuery>;\nexport type GetSharePlanSuspenseQueryHookResult = ReturnType<typeof useGetSharePlanSuspenseQuery>;\nexport type GetSharePlanQueryResult = Apollo.QueryResult<GetSharePlanQuery, GetSharePlanQueryVariables>;\nexport function refetchGetSharePlanQuery(variables: GetSharePlanQueryVariables) {\n      return { query: GetSharePlanDocument, variables: variables };\n    }\nexport const GetPlanGroupEssDocument: TypedDocumentNode<GetPlanGroupEssQuery, GetPlanGroupEssQueryVariables> = gql`\n  query getPlanGroupESS($groupId: EssOfferGroupCakeType!) {\n  group: essOfferGroup(group: $groupId) {\n    id\n    country\n    offerCount\n    offerAcceptedCount\n    loanFunded\n    totalGranted\n    totalVested\n    totalLapsed\n    offerLetterTemplate {\n      id\n      name\n      contractType\n      status\n      modified\n    }\n    planRulesTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n      modified\n    }\n    plan {\n      id\n      name\n    }\n    sharetype {\n      id\n      name\n      symbol\n    }\n    isEditable\n  }\n}\n    `;\n\n/**\n * __useGetPlanGroupEssQuery__\n *\n * To run a query within a React component, call `useGetPlanGroupEssQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanGroupEssQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanGroupEssQuery({\n *   variables: {\n *      groupId: // value for 'groupId'\n *   },\n * });\n */\nexport function useGetPlanGroupEssQuery(baseOptions: Apollo.QueryHookOptions<GetPlanGroupEssQuery, GetPlanGroupEssQueryVariables> & ({ variables: GetPlanGroupEssQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanGroupEssQuery, GetPlanGroupEssQueryVariables>(GetPlanGroupEssDocument, options);\n      }\nexport function useGetPlanGroupEssLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanGroupEssQuery, GetPlanGroupEssQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanGroupEssQuery, GetPlanGroupEssQueryVariables>(GetPlanGroupEssDocument, options);\n        }\nexport function useGetPlanGroupEssSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanGroupEssQuery, GetPlanGroupEssQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanGroupEssQuery, GetPlanGroupEssQueryVariables>(GetPlanGroupEssDocument, options);\n        }\nexport type GetPlanGroupEssQueryHookResult = ReturnType<typeof useGetPlanGroupEssQuery>;\nexport type GetPlanGroupEssLazyQueryHookResult = ReturnType<typeof useGetPlanGroupEssLazyQuery>;\nexport type GetPlanGroupEssSuspenseQueryHookResult = ReturnType<typeof useGetPlanGroupEssSuspenseQuery>;\nexport type GetPlanGroupEssQueryResult = Apollo.QueryResult<GetPlanGroupEssQuery, GetPlanGroupEssQueryVariables>;\nexport function refetchGetPlanGroupEssQuery(variables: GetPlanGroupEssQueryVariables) {\n      return { query: GetPlanGroupEssDocument, variables: variables };\n    }\nexport const GetPlanOffersToCompleteEssDocument: TypedDocumentNode<GetPlanOffersToCompleteEssQuery, GetPlanOffersToCompleteEssQueryVariables> = gql`\n  query getPlanOffersToCompleteESS($organisationId: UUID!, $offerIds: [UUID]!) {\n  offers: essOffersToComplete(\n    organisationId: $organisationId\n    offerIds: $offerIds\n  ) {\n    id\n    vestStartDate\n    country\n    status\n    sharePrice\n    sharePriceReal\n    shareholderDisplayName\n    shareholder: shareholderOpt {\n      id\n      secondaryName\n      avatar\n      recipient {\n        id\n        displayName\n      }\n      investorData {\n        name\n        email\n        jointIndex\n        companyData {\n          signers {\n            name\n            email\n          }\n        }\n      }\n    }\n    offerLetterTemplate {\n      id\n    }\n    group {\n      id\n      country\n      offerLetterTemplate {\n        id\n        name\n        status\n        contractType\n        modified\n      }\n      planRulesTemplate {\n        id\n        name\n        status\n        type\n        contractType\n        modified\n        extension\n      }\n      defaultPlanRulesTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      defaultOfferLetterTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOffersToCompleteEssQuery__\n *\n * To run a query within a React component, call `useGetPlanOffersToCompleteEssQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOffersToCompleteEssQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOffersToCompleteEssQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      offerIds: // value for 'offerIds'\n *   },\n * });\n */\nexport function useGetPlanOffersToCompleteEssQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOffersToCompleteEssQuery, GetPlanOffersToCompleteEssQueryVariables> & ({ variables: GetPlanOffersToCompleteEssQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOffersToCompleteEssQuery, GetPlanOffersToCompleteEssQueryVariables>(GetPlanOffersToCompleteEssDocument, options);\n      }\nexport function useGetPlanOffersToCompleteEssLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOffersToCompleteEssQuery, GetPlanOffersToCompleteEssQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOffersToCompleteEssQuery, GetPlanOffersToCompleteEssQueryVariables>(GetPlanOffersToCompleteEssDocument, options);\n        }\nexport function useGetPlanOffersToCompleteEssSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOffersToCompleteEssQuery, GetPlanOffersToCompleteEssQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOffersToCompleteEssQuery, GetPlanOffersToCompleteEssQueryVariables>(GetPlanOffersToCompleteEssDocument, options);\n        }\nexport type GetPlanOffersToCompleteEssQueryHookResult = ReturnType<typeof useGetPlanOffersToCompleteEssQuery>;\nexport type GetPlanOffersToCompleteEssLazyQueryHookResult = ReturnType<typeof useGetPlanOffersToCompleteEssLazyQuery>;\nexport type GetPlanOffersToCompleteEssSuspenseQueryHookResult = ReturnType<typeof useGetPlanOffersToCompleteEssSuspenseQuery>;\nexport type GetPlanOffersToCompleteEssQueryResult = Apollo.QueryResult<GetPlanOffersToCompleteEssQuery, GetPlanOffersToCompleteEssQueryVariables>;\nexport function refetchGetPlanOffersToCompleteEssQuery(variables: GetPlanOffersToCompleteEssQueryVariables) {\n      return { query: GetPlanOffersToCompleteEssDocument, variables: variables };\n    }\nexport const GetPlanOffersEssDocument: TypedDocumentNode<GetPlanOffersEssQuery, GetPlanOffersEssQueryVariables> = gql`\n  query getPlanOffersESS($organisationId: UUID!, $filterId: UUID!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $filters: [ListFilterType!], $sort: [CleanString!], $search: String) {\n  offers: sharePlanOffers(\n    organisationId: $organisationId\n    filterId: $filterId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    filters: $filters\n    sort: $sort\n    search: $search\n  ) {\n    plan {\n      id\n      vestingValue\n      totalOffered\n      totalLapsed\n      organisation {\n        fullyDilutedShares\n      }\n    }\n    count\n    currentPage\n    notSignedUpCount\n    shareholderCount\n    pageData {\n      id\n      modified\n      groupId\n      planId\n      offerLetterId\n      dateGranted\n      vestStartDate\n      emailsOn\n      requireWitness\n      shareholderId\n      shareholderDisplayName\n      shareholderSecondaryName\n      shareholderAvatar\n      shareholderHasLoggedIn\n      shareholderConsideredInvited\n      shEmail\n      stakeholderType: shareholderType\n      isTrust: shareholderIsTrust\n      status\n      softStatus\n      country\n      vestingValue\n      availableToLapse\n      availableToExercise\n      availableToVest\n      vested\n      granted\n      lapsed\n      exercised\n      hasOngoingPauseEvents\n      hasScheduledPauseEvents\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOffersEssQuery__\n *\n * To run a query within a React component, call `useGetPlanOffersEssQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOffersEssQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOffersEssQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      filterId: // value for 'filterId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      filters: // value for 'filters'\n *      sort: // value for 'sort'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetPlanOffersEssQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOffersEssQuery, GetPlanOffersEssQueryVariables> & ({ variables: GetPlanOffersEssQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOffersEssQuery, GetPlanOffersEssQueryVariables>(GetPlanOffersEssDocument, options);\n      }\nexport function useGetPlanOffersEssLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOffersEssQuery, GetPlanOffersEssQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOffersEssQuery, GetPlanOffersEssQueryVariables>(GetPlanOffersEssDocument, options);\n        }\nexport function useGetPlanOffersEssSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOffersEssQuery, GetPlanOffersEssQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOffersEssQuery, GetPlanOffersEssQueryVariables>(GetPlanOffersEssDocument, options);\n        }\nexport type GetPlanOffersEssQueryHookResult = ReturnType<typeof useGetPlanOffersEssQuery>;\nexport type GetPlanOffersEssLazyQueryHookResult = ReturnType<typeof useGetPlanOffersEssLazyQuery>;\nexport type GetPlanOffersEssSuspenseQueryHookResult = ReturnType<typeof useGetPlanOffersEssSuspenseQuery>;\nexport type GetPlanOffersEssQueryResult = Apollo.QueryResult<GetPlanOffersEssQuery, GetPlanOffersEssQueryVariables>;\nexport function refetchGetPlanOffersEssQuery(variables: GetPlanOffersEssQueryVariables) {\n      return { query: GetPlanOffersEssDocument, variables: variables };\n    }\nexport const OffersVestingEventsEssDocument: TypedDocumentNode<OffersVestingEventsEssQuery, OffersVestingEventsEssQueryVariables> = gql`\n  query offersVestingEventsESS($offerIds: [UUID!]!) {\n  offersVestingEvents: essOffersVestingEvents(offerIds: $offerIds) {\n    id\n    offerId\n    order\n    vestingValue\n    eventType\n    vestingData {\n      description\n      duration {\n        value\n        granularity\n      }\n      frequency {\n        value\n        granularity\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useOffersVestingEventsEssQuery__\n *\n * To run a query within a React component, call `useOffersVestingEventsEssQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffersVestingEventsEssQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffersVestingEventsEssQuery({\n *   variables: {\n *      offerIds: // value for 'offerIds'\n *   },\n * });\n */\nexport function useOffersVestingEventsEssQuery(baseOptions: Apollo.QueryHookOptions<OffersVestingEventsEssQuery, OffersVestingEventsEssQueryVariables> & ({ variables: OffersVestingEventsEssQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffersVestingEventsEssQuery, OffersVestingEventsEssQueryVariables>(OffersVestingEventsEssDocument, options);\n      }\nexport function useOffersVestingEventsEssLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffersVestingEventsEssQuery, OffersVestingEventsEssQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffersVestingEventsEssQuery, OffersVestingEventsEssQueryVariables>(OffersVestingEventsEssDocument, options);\n        }\nexport function useOffersVestingEventsEssSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffersVestingEventsEssQuery, OffersVestingEventsEssQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffersVestingEventsEssQuery, OffersVestingEventsEssQueryVariables>(OffersVestingEventsEssDocument, options);\n        }\nexport type OffersVestingEventsEssQueryHookResult = ReturnType<typeof useOffersVestingEventsEssQuery>;\nexport type OffersVestingEventsEssLazyQueryHookResult = ReturnType<typeof useOffersVestingEventsEssLazyQuery>;\nexport type OffersVestingEventsEssSuspenseQueryHookResult = ReturnType<typeof useOffersVestingEventsEssSuspenseQuery>;\nexport type OffersVestingEventsEssQueryResult = Apollo.QueryResult<OffersVestingEventsEssQuery, OffersVestingEventsEssQueryVariables>;\nexport function refetchOffersVestingEventsEssQuery(variables: OffersVestingEventsEssQueryVariables) {\n      return { query: OffersVestingEventsEssDocument, variables: variables };\n    }\nexport const EssOfferDocument: TypedDocumentNode<EssOfferQuery, EssOfferQueryVariables> = gql`\n  query essOffer($offerId: UUID!) {\n  offer: essOffer(offerId: $offerId) {\n    id\n    created\n    modified\n    sharePrice\n    sharePriceReal\n    loanFunded\n    group {\n      sharetype {\n        id\n        name\n        symbol\n      }\n      plan {\n        id\n        name\n        vestingValue\n        totalOffered\n        totalLapsed\n        documents {\n          id\n          name\n          extension\n          created\n          type\n        }\n        organisation {\n          id\n          name\n          logoImage: logoImageLink\n          country\n          currency\n          totalShares\n          created\n          valuationAt {\n            valuation\n          }\n          totalSharesUnexercised\n          fullyDilutedShares\n          valuationVisibleToOptionholders\n        }\n        group: offerGroup {\n          id\n          country\n          sharetype {\n            symbol\n            voting\n            dividend\n          }\n          offerLetterTemplate {\n            id\n            name\n            contractType\n            status\n            modified\n          }\n          planRulesTemplate {\n            id\n            name\n            contractType\n            status\n            type\n            extension\n            modified\n          }\n        }\n      }\n    }\n    shareholder {\n      id\n      displayName\n      avatar\n      trustAbn\n      heldInTrust\n      trustName\n      inviteLink\n      computedType\n      investorData {\n        name\n        email\n        phone\n        jointIndex\n        address {\n          line2\n          line1\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n        companyData {\n          contactPerson\n          identifierType\n          identifierNumber\n          signers {\n            name\n            email\n            role\n          }\n        }\n      }\n      recipient {\n        id\n        displayName\n        avatar\n        trustAbn\n        heldInTrust\n        trustName\n        inviteLink\n        computedType\n        investorData {\n          name\n          email\n          phone\n          jointIndex\n          address {\n            line2\n            line1\n            locality\n            administrativeArea1\n            postcode\n            country\n          }\n          companyData {\n            contactPerson\n            identifierType\n            identifierNumber\n            signers {\n              name\n              email\n              role\n            }\n          }\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useEssOfferQuery__\n *\n * To run a query within a React component, call `useEssOfferQuery` and pass it any options that fit your needs.\n * When your component renders, `useEssOfferQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useEssOfferQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useEssOfferQuery(baseOptions: Apollo.QueryHookOptions<EssOfferQuery, EssOfferQueryVariables> & ({ variables: EssOfferQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<EssOfferQuery, EssOfferQueryVariables>(EssOfferDocument, options);\n      }\nexport function useEssOfferLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EssOfferQuery, EssOfferQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<EssOfferQuery, EssOfferQueryVariables>(EssOfferDocument, options);\n        }\nexport function useEssOfferSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<EssOfferQuery, EssOfferQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<EssOfferQuery, EssOfferQueryVariables>(EssOfferDocument, options);\n        }\nexport type EssOfferQueryHookResult = ReturnType<typeof useEssOfferQuery>;\nexport type EssOfferLazyQueryHookResult = ReturnType<typeof useEssOfferLazyQuery>;\nexport type EssOfferSuspenseQueryHookResult = ReturnType<typeof useEssOfferSuspenseQuery>;\nexport type EssOfferQueryResult = Apollo.QueryResult<EssOfferQuery, EssOfferQueryVariables>;\nexport function refetchEssOfferQuery(variables: EssOfferQueryVariables) {\n      return { query: EssOfferDocument, variables: variables };\n    }\nexport const GetDataToVestOfferFoundervestingDocument: TypedDocumentNode<GetDataToVestOfferFoundervestingQuery, GetDataToVestOfferFoundervestingQueryVariables> = gql`\n  query getDataToVestOfferFOUNDERVESTING($offer: UUID!) {\n  investorHoldings: founderVestingOffer(offerId: $offer) {\n    availableToPeriodicVest\n    vested\n    id\n    vestingEvents {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: foundervestingtransactionSet {\n        id\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n        reminderDate\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetDataToVestOfferFoundervestingQuery__\n *\n * To run a query within a React component, call `useGetDataToVestOfferFoundervestingQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDataToVestOfferFoundervestingQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDataToVestOfferFoundervestingQuery({\n *   variables: {\n *      offer: // value for 'offer'\n *   },\n * });\n */\nexport function useGetDataToVestOfferFoundervestingQuery(baseOptions: Apollo.QueryHookOptions<GetDataToVestOfferFoundervestingQuery, GetDataToVestOfferFoundervestingQueryVariables> & ({ variables: GetDataToVestOfferFoundervestingQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDataToVestOfferFoundervestingQuery, GetDataToVestOfferFoundervestingQueryVariables>(GetDataToVestOfferFoundervestingDocument, options);\n      }\nexport function useGetDataToVestOfferFoundervestingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDataToVestOfferFoundervestingQuery, GetDataToVestOfferFoundervestingQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDataToVestOfferFoundervestingQuery, GetDataToVestOfferFoundervestingQueryVariables>(GetDataToVestOfferFoundervestingDocument, options);\n        }\nexport function useGetDataToVestOfferFoundervestingSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDataToVestOfferFoundervestingQuery, GetDataToVestOfferFoundervestingQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDataToVestOfferFoundervestingQuery, GetDataToVestOfferFoundervestingQueryVariables>(GetDataToVestOfferFoundervestingDocument, options);\n        }\nexport type GetDataToVestOfferFoundervestingQueryHookResult = ReturnType<typeof useGetDataToVestOfferFoundervestingQuery>;\nexport type GetDataToVestOfferFoundervestingLazyQueryHookResult = ReturnType<typeof useGetDataToVestOfferFoundervestingLazyQuery>;\nexport type GetDataToVestOfferFoundervestingSuspenseQueryHookResult = ReturnType<typeof useGetDataToVestOfferFoundervestingSuspenseQuery>;\nexport type GetDataToVestOfferFoundervestingQueryResult = Apollo.QueryResult<GetDataToVestOfferFoundervestingQuery, GetDataToVestOfferFoundervestingQueryVariables>;\nexport function refetchGetDataToVestOfferFoundervestingQuery(variables: GetDataToVestOfferFoundervestingQueryVariables) {\n      return { query: GetDataToVestOfferFoundervestingDocument, variables: variables };\n    }\nexport const GetDataToLapseOfferFoundervestingDocument: TypedDocumentNode<GetDataToLapseOfferFoundervestingQuery, GetDataToLapseOfferFoundervestingQueryVariables> = gql`\n  query getDataToLapseOfferFOUNDERVESTING($offer: UUID!) {\n  lapseData: founderVestingOffer(offerId: $offer) {\n    id\n    vestStartDate\n    softStatus\n    granted\n    vestablePeriodic\n    lapsed\n    lapsedPeriodic\n    exercised\n    availableToPeriodicVest\n    availableToVestMilestone\n    availableToLapse\n    pauseEvents {\n      status\n    }\n    shareholder {\n      id\n      displayName\n    }\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        entryType\n      }\n    }\n    vestingEvents {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: foundervestingtransactionSet {\n        id\n        transactionDate\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetDataToLapseOfferFoundervestingQuery__\n *\n * To run a query within a React component, call `useGetDataToLapseOfferFoundervestingQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDataToLapseOfferFoundervestingQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDataToLapseOfferFoundervestingQuery({\n *   variables: {\n *      offer: // value for 'offer'\n *   },\n * });\n */\nexport function useGetDataToLapseOfferFoundervestingQuery(baseOptions: Apollo.QueryHookOptions<GetDataToLapseOfferFoundervestingQuery, GetDataToLapseOfferFoundervestingQueryVariables> & ({ variables: GetDataToLapseOfferFoundervestingQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDataToLapseOfferFoundervestingQuery, GetDataToLapseOfferFoundervestingQueryVariables>(GetDataToLapseOfferFoundervestingDocument, options);\n      }\nexport function useGetDataToLapseOfferFoundervestingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDataToLapseOfferFoundervestingQuery, GetDataToLapseOfferFoundervestingQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDataToLapseOfferFoundervestingQuery, GetDataToLapseOfferFoundervestingQueryVariables>(GetDataToLapseOfferFoundervestingDocument, options);\n        }\nexport function useGetDataToLapseOfferFoundervestingSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDataToLapseOfferFoundervestingQuery, GetDataToLapseOfferFoundervestingQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDataToLapseOfferFoundervestingQuery, GetDataToLapseOfferFoundervestingQueryVariables>(GetDataToLapseOfferFoundervestingDocument, options);\n        }\nexport type GetDataToLapseOfferFoundervestingQueryHookResult = ReturnType<typeof useGetDataToLapseOfferFoundervestingQuery>;\nexport type GetDataToLapseOfferFoundervestingLazyQueryHookResult = ReturnType<typeof useGetDataToLapseOfferFoundervestingLazyQuery>;\nexport type GetDataToLapseOfferFoundervestingSuspenseQueryHookResult = ReturnType<typeof useGetDataToLapseOfferFoundervestingSuspenseQuery>;\nexport type GetDataToLapseOfferFoundervestingQueryResult = Apollo.QueryResult<GetDataToLapseOfferFoundervestingQuery, GetDataToLapseOfferFoundervestingQueryVariables>;\nexport function refetchGetDataToLapseOfferFoundervestingQuery(variables: GetDataToLapseOfferFoundervestingQueryVariables) {\n      return { query: GetDataToLapseOfferFoundervestingDocument, variables: variables };\n    }\nexport const GetDataToPauseFoundervestingDocument: TypedDocumentNode<GetDataToPauseFoundervestingQuery, GetDataToPauseFoundervestingQueryVariables> = gql`\n  query getDataToPauseFOUNDERVESTING($offerId: UUID!) {\n  offer: founderVestingOffer(offerId: $offerId) {\n    id\n    softStatus\n    pauseEvents {\n      id\n      pauseDate\n      resumeDate\n      status\n    }\n  }\n}\n    `;\n\n/**\n * __useGetDataToPauseFoundervestingQuery__\n *\n * To run a query within a React component, call `useGetDataToPauseFoundervestingQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDataToPauseFoundervestingQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDataToPauseFoundervestingQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useGetDataToPauseFoundervestingQuery(baseOptions: Apollo.QueryHookOptions<GetDataToPauseFoundervestingQuery, GetDataToPauseFoundervestingQueryVariables> & ({ variables: GetDataToPauseFoundervestingQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDataToPauseFoundervestingQuery, GetDataToPauseFoundervestingQueryVariables>(GetDataToPauseFoundervestingDocument, options);\n      }\nexport function useGetDataToPauseFoundervestingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDataToPauseFoundervestingQuery, GetDataToPauseFoundervestingQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDataToPauseFoundervestingQuery, GetDataToPauseFoundervestingQueryVariables>(GetDataToPauseFoundervestingDocument, options);\n        }\nexport function useGetDataToPauseFoundervestingSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDataToPauseFoundervestingQuery, GetDataToPauseFoundervestingQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDataToPauseFoundervestingQuery, GetDataToPauseFoundervestingQueryVariables>(GetDataToPauseFoundervestingDocument, options);\n        }\nexport type GetDataToPauseFoundervestingQueryHookResult = ReturnType<typeof useGetDataToPauseFoundervestingQuery>;\nexport type GetDataToPauseFoundervestingLazyQueryHookResult = ReturnType<typeof useGetDataToPauseFoundervestingLazyQuery>;\nexport type GetDataToPauseFoundervestingSuspenseQueryHookResult = ReturnType<typeof useGetDataToPauseFoundervestingSuspenseQuery>;\nexport type GetDataToPauseFoundervestingQueryResult = Apollo.QueryResult<GetDataToPauseFoundervestingQuery, GetDataToPauseFoundervestingQueryVariables>;\nexport function refetchGetDataToPauseFoundervestingQuery(variables: GetDataToPauseFoundervestingQueryVariables) {\n      return { query: GetDataToPauseFoundervestingDocument, variables: variables };\n    }\nexport const DeleteOffersFoundervestingDocument: TypedDocumentNode<DeleteOffersFoundervestingMutation, DeleteOffersFoundervestingMutationVariables> = gql`\n  mutation deleteOffersFOUNDERVESTING($offers: [FounderVestingOfferCakeType]!) {\n  deleteOffersFounderVesting(offers: $offers)\n}\n    `;\nexport type DeleteOffersFoundervestingMutationFn = Apollo.MutationFunction<DeleteOffersFoundervestingMutation, DeleteOffersFoundervestingMutationVariables>;\n\n/**\n * __useDeleteOffersFoundervestingMutation__\n *\n * To run a mutation, you first call `useDeleteOffersFoundervestingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteOffersFoundervestingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteOffersFoundervestingMutation, { data, loading, error }] = useDeleteOffersFoundervestingMutation({\n *   variables: {\n *      offers: // value for 'offers'\n *   },\n * });\n */\nexport function useDeleteOffersFoundervestingMutation(baseOptions?: Apollo.MutationHookOptions<DeleteOffersFoundervestingMutation, DeleteOffersFoundervestingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteOffersFoundervestingMutation, DeleteOffersFoundervestingMutationVariables>(DeleteOffersFoundervestingDocument, options);\n      }\nexport type DeleteOffersFoundervestingMutationHookResult = ReturnType<typeof useDeleteOffersFoundervestingMutation>;\nexport type DeleteOffersFoundervestingMutationResult = Apollo.MutationResult<DeleteOffersFoundervestingMutation>;\nexport type DeleteOffersFoundervestingMutationOptions = Apollo.BaseMutationOptions<DeleteOffersFoundervestingMutation, DeleteOffersFoundervestingMutationVariables>;\nexport const LapseOfferFoundervestingDocument: TypedDocumentNode<LapseOfferFoundervestingMutation, LapseOfferFoundervestingMutationVariables> = gql`\n  mutation lapseOfferFOUNDERVESTING($offer: FounderVestingOfferCakeType!, $lapseDate: Date!, $acceleratedValue: PositiveIntegerOrZero!) {\n  lapseOfferFounderVesting(\n    offer: $offer\n    lapseDate: $lapseDate\n    acceleratedValue: $acceleratedValue\n  )\n}\n    `;\nexport type LapseOfferFoundervestingMutationFn = Apollo.MutationFunction<LapseOfferFoundervestingMutation, LapseOfferFoundervestingMutationVariables>;\n\n/**\n * __useLapseOfferFoundervestingMutation__\n *\n * To run a mutation, you first call `useLapseOfferFoundervestingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useLapseOfferFoundervestingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [lapseOfferFoundervestingMutation, { data, loading, error }] = useLapseOfferFoundervestingMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      lapseDate: // value for 'lapseDate'\n *      acceleratedValue: // value for 'acceleratedValue'\n *   },\n * });\n */\nexport function useLapseOfferFoundervestingMutation(baseOptions?: Apollo.MutationHookOptions<LapseOfferFoundervestingMutation, LapseOfferFoundervestingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<LapseOfferFoundervestingMutation, LapseOfferFoundervestingMutationVariables>(LapseOfferFoundervestingDocument, options);\n      }\nexport type LapseOfferFoundervestingMutationHookResult = ReturnType<typeof useLapseOfferFoundervestingMutation>;\nexport type LapseOfferFoundervestingMutationResult = Apollo.MutationResult<LapseOfferFoundervestingMutation>;\nexport type LapseOfferFoundervestingMutationOptions = Apollo.BaseMutationOptions<LapseOfferFoundervestingMutation, LapseOfferFoundervestingMutationVariables>;\nexport const LapseOfferMilestoneFoundervestingDocument: TypedDocumentNode<LapseOfferMilestoneFoundervestingMutation, LapseOfferMilestoneFoundervestingMutationVariables> = gql`\n  mutation lapseOfferMilestoneFOUNDERVESTING($offer: FounderVestingOfferCakeType!, $lapseDate: Date!, $milestoneEvents: [LapseMilestoneEntryInputType!]!) {\n  lapseMilestoneFounderVesting(\n    offer: $offer\n    lapseDate: $lapseDate\n    milestoneEvents: $milestoneEvents\n  )\n}\n    `;\nexport type LapseOfferMilestoneFoundervestingMutationFn = Apollo.MutationFunction<LapseOfferMilestoneFoundervestingMutation, LapseOfferMilestoneFoundervestingMutationVariables>;\n\n/**\n * __useLapseOfferMilestoneFoundervestingMutation__\n *\n * To run a mutation, you first call `useLapseOfferMilestoneFoundervestingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useLapseOfferMilestoneFoundervestingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [lapseOfferMilestoneFoundervestingMutation, { data, loading, error }] = useLapseOfferMilestoneFoundervestingMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      lapseDate: // value for 'lapseDate'\n *      milestoneEvents: // value for 'milestoneEvents'\n *   },\n * });\n */\nexport function useLapseOfferMilestoneFoundervestingMutation(baseOptions?: Apollo.MutationHookOptions<LapseOfferMilestoneFoundervestingMutation, LapseOfferMilestoneFoundervestingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<LapseOfferMilestoneFoundervestingMutation, LapseOfferMilestoneFoundervestingMutationVariables>(LapseOfferMilestoneFoundervestingDocument, options);\n      }\nexport type LapseOfferMilestoneFoundervestingMutationHookResult = ReturnType<typeof useLapseOfferMilestoneFoundervestingMutation>;\nexport type LapseOfferMilestoneFoundervestingMutationResult = Apollo.MutationResult<LapseOfferMilestoneFoundervestingMutation>;\nexport type LapseOfferMilestoneFoundervestingMutationOptions = Apollo.BaseMutationOptions<LapseOfferMilestoneFoundervestingMutation, LapseOfferMilestoneFoundervestingMutationVariables>;\nexport const FullyLapseOfferFoundervestingDocument: TypedDocumentNode<FullyLapseOfferFoundervestingMutation, FullyLapseOfferFoundervestingMutationVariables> = gql`\n  mutation fullyLapseOfferFOUNDERVESTING($offer: FounderVestingOfferCakeType!, $transactionDate: Date!, $acceleratedValue: PositiveIntegerOrZero!) {\n  fullyLapseOfferFounderVesting(\n    offer: $offer\n    transactionDate: $transactionDate\n    acceleratedValue: $acceleratedValue\n  )\n}\n    `;\nexport type FullyLapseOfferFoundervestingMutationFn = Apollo.MutationFunction<FullyLapseOfferFoundervestingMutation, FullyLapseOfferFoundervestingMutationVariables>;\n\n/**\n * __useFullyLapseOfferFoundervestingMutation__\n *\n * To run a mutation, you first call `useFullyLapseOfferFoundervestingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useFullyLapseOfferFoundervestingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [fullyLapseOfferFoundervestingMutation, { data, loading, error }] = useFullyLapseOfferFoundervestingMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      transactionDate: // value for 'transactionDate'\n *      acceleratedValue: // value for 'acceleratedValue'\n *   },\n * });\n */\nexport function useFullyLapseOfferFoundervestingMutation(baseOptions?: Apollo.MutationHookOptions<FullyLapseOfferFoundervestingMutation, FullyLapseOfferFoundervestingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<FullyLapseOfferFoundervestingMutation, FullyLapseOfferFoundervestingMutationVariables>(FullyLapseOfferFoundervestingDocument, options);\n      }\nexport type FullyLapseOfferFoundervestingMutationHookResult = ReturnType<typeof useFullyLapseOfferFoundervestingMutation>;\nexport type FullyLapseOfferFoundervestingMutationResult = Apollo.MutationResult<FullyLapseOfferFoundervestingMutation>;\nexport type FullyLapseOfferFoundervestingMutationOptions = Apollo.BaseMutationOptions<FullyLapseOfferFoundervestingMutation, FullyLapseOfferFoundervestingMutationVariables>;\nexport const VestCliffOrPeriodicFoundervestingDocument: TypedDocumentNode<VestCliffOrPeriodicFoundervestingMutation, VestCliffOrPeriodicFoundervestingMutationVariables> = gql`\n  mutation vestCliffOrPeriodicFOUNDERVESTING($offer: FounderVestingOfferCakeType!, $transactionDate: Date!, $vestingValue: PositiveIntegerOrZero!) {\n  vestCliffOrPeriodicFounderVesting(\n    offer: $offer\n    transactionDate: $transactionDate\n    vestingValue: $vestingValue\n  )\n}\n    `;\nexport type VestCliffOrPeriodicFoundervestingMutationFn = Apollo.MutationFunction<VestCliffOrPeriodicFoundervestingMutation, VestCliffOrPeriodicFoundervestingMutationVariables>;\n\n/**\n * __useVestCliffOrPeriodicFoundervestingMutation__\n *\n * To run a mutation, you first call `useVestCliffOrPeriodicFoundervestingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useVestCliffOrPeriodicFoundervestingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [vestCliffOrPeriodicFoundervestingMutation, { data, loading, error }] = useVestCliffOrPeriodicFoundervestingMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      transactionDate: // value for 'transactionDate'\n *      vestingValue: // value for 'vestingValue'\n *   },\n * });\n */\nexport function useVestCliffOrPeriodicFoundervestingMutation(baseOptions?: Apollo.MutationHookOptions<VestCliffOrPeriodicFoundervestingMutation, VestCliffOrPeriodicFoundervestingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<VestCliffOrPeriodicFoundervestingMutation, VestCliffOrPeriodicFoundervestingMutationVariables>(VestCliffOrPeriodicFoundervestingDocument, options);\n      }\nexport type VestCliffOrPeriodicFoundervestingMutationHookResult = ReturnType<typeof useVestCliffOrPeriodicFoundervestingMutation>;\nexport type VestCliffOrPeriodicFoundervestingMutationResult = Apollo.MutationResult<VestCliffOrPeriodicFoundervestingMutation>;\nexport type VestCliffOrPeriodicFoundervestingMutationOptions = Apollo.BaseMutationOptions<VestCliffOrPeriodicFoundervestingMutation, VestCliffOrPeriodicFoundervestingMutationVariables>;\nexport const VestOfferMilestonesFoundervestingDocument: TypedDocumentNode<VestOfferMilestonesFoundervestingMutation, VestOfferMilestonesFoundervestingMutationVariables> = gql`\n  mutation vestOfferMilestonesFOUNDERVESTING($milestoneList: [MilestoneVestType]!) {\n  vestOfferMilestonesFounderVesting(milestoneList: $milestoneList)\n}\n    `;\nexport type VestOfferMilestonesFoundervestingMutationFn = Apollo.MutationFunction<VestOfferMilestonesFoundervestingMutation, VestOfferMilestonesFoundervestingMutationVariables>;\n\n/**\n * __useVestOfferMilestonesFoundervestingMutation__\n *\n * To run a mutation, you first call `useVestOfferMilestonesFoundervestingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useVestOfferMilestonesFoundervestingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [vestOfferMilestonesFoundervestingMutation, { data, loading, error }] = useVestOfferMilestonesFoundervestingMutation({\n *   variables: {\n *      milestoneList: // value for 'milestoneList'\n *   },\n * });\n */\nexport function useVestOfferMilestonesFoundervestingMutation(baseOptions?: Apollo.MutationHookOptions<VestOfferMilestonesFoundervestingMutation, VestOfferMilestonesFoundervestingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<VestOfferMilestonesFoundervestingMutation, VestOfferMilestonesFoundervestingMutationVariables>(VestOfferMilestonesFoundervestingDocument, options);\n      }\nexport type VestOfferMilestonesFoundervestingMutationHookResult = ReturnType<typeof useVestOfferMilestonesFoundervestingMutation>;\nexport type VestOfferMilestonesFoundervestingMutationResult = Apollo.MutationResult<VestOfferMilestonesFoundervestingMutation>;\nexport type VestOfferMilestonesFoundervestingMutationOptions = Apollo.BaseMutationOptions<VestOfferMilestonesFoundervestingMutation, VestOfferMilestonesFoundervestingMutationVariables>;\nexport const CreateOfferPauseEventFoundervestingDocument: TypedDocumentNode<CreateOfferPauseEventFoundervestingMutation, CreateOfferPauseEventFoundervestingMutationVariables> = gql`\n  mutation createOfferPauseEventFOUNDERVESTING($founderVestingOffer: FounderVestingOfferCakeType!, $pauseDate: Date!, $resumeDate: Date, $forceSave: Boolean) {\n  createOfferPauseEventFounderVesting(\n    offer: $founderVestingOffer\n    pauseDate: $pauseDate\n    resumeDate: $resumeDate\n    forceSave: $forceSave\n  )\n}\n    `;\nexport type CreateOfferPauseEventFoundervestingMutationFn = Apollo.MutationFunction<CreateOfferPauseEventFoundervestingMutation, CreateOfferPauseEventFoundervestingMutationVariables>;\n\n/**\n * __useCreateOfferPauseEventFoundervestingMutation__\n *\n * To run a mutation, you first call `useCreateOfferPauseEventFoundervestingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateOfferPauseEventFoundervestingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createOfferPauseEventFoundervestingMutation, { data, loading, error }] = useCreateOfferPauseEventFoundervestingMutation({\n *   variables: {\n *      founderVestingOffer: // value for 'founderVestingOffer'\n *      pauseDate: // value for 'pauseDate'\n *      resumeDate: // value for 'resumeDate'\n *      forceSave: // value for 'forceSave'\n *   },\n * });\n */\nexport function useCreateOfferPauseEventFoundervestingMutation(baseOptions?: Apollo.MutationHookOptions<CreateOfferPauseEventFoundervestingMutation, CreateOfferPauseEventFoundervestingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateOfferPauseEventFoundervestingMutation, CreateOfferPauseEventFoundervestingMutationVariables>(CreateOfferPauseEventFoundervestingDocument, options);\n      }\nexport type CreateOfferPauseEventFoundervestingMutationHookResult = ReturnType<typeof useCreateOfferPauseEventFoundervestingMutation>;\nexport type CreateOfferPauseEventFoundervestingMutationResult = Apollo.MutationResult<CreateOfferPauseEventFoundervestingMutation>;\nexport type CreateOfferPauseEventFoundervestingMutationOptions = Apollo.BaseMutationOptions<CreateOfferPauseEventFoundervestingMutation, CreateOfferPauseEventFoundervestingMutationVariables>;\nexport const EditOfferPauseEventFoundervestingDocument: TypedDocumentNode<EditOfferPauseEventFoundervestingMutation, EditOfferPauseEventFoundervestingMutationVariables> = gql`\n  mutation editOfferPauseEventFOUNDERVESTING($pauseEvent: FounderVestingOfferPauseEventCakeType!, $pauseDate: Date!, $resumeDate: Date, $forceSave: Boolean) {\n  editOfferPauseEventFounderVesting(\n    pauseEvent: $pauseEvent\n    pauseDate: $pauseDate\n    resumeDate: $resumeDate\n    forceSave: $forceSave\n  )\n}\n    `;\nexport type EditOfferPauseEventFoundervestingMutationFn = Apollo.MutationFunction<EditOfferPauseEventFoundervestingMutation, EditOfferPauseEventFoundervestingMutationVariables>;\n\n/**\n * __useEditOfferPauseEventFoundervestingMutation__\n *\n * To run a mutation, you first call `useEditOfferPauseEventFoundervestingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditOfferPauseEventFoundervestingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editOfferPauseEventFoundervestingMutation, { data, loading, error }] = useEditOfferPauseEventFoundervestingMutation({\n *   variables: {\n *      pauseEvent: // value for 'pauseEvent'\n *      pauseDate: // value for 'pauseDate'\n *      resumeDate: // value for 'resumeDate'\n *      forceSave: // value for 'forceSave'\n *   },\n * });\n */\nexport function useEditOfferPauseEventFoundervestingMutation(baseOptions?: Apollo.MutationHookOptions<EditOfferPauseEventFoundervestingMutation, EditOfferPauseEventFoundervestingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditOfferPauseEventFoundervestingMutation, EditOfferPauseEventFoundervestingMutationVariables>(EditOfferPauseEventFoundervestingDocument, options);\n      }\nexport type EditOfferPauseEventFoundervestingMutationHookResult = ReturnType<typeof useEditOfferPauseEventFoundervestingMutation>;\nexport type EditOfferPauseEventFoundervestingMutationResult = Apollo.MutationResult<EditOfferPauseEventFoundervestingMutation>;\nexport type EditOfferPauseEventFoundervestingMutationOptions = Apollo.BaseMutationOptions<EditOfferPauseEventFoundervestingMutation, EditOfferPauseEventFoundervestingMutationVariables>;\nexport const DeleteOfferPauseEventFoundervestingDocument: TypedDocumentNode<DeleteOfferPauseEventFoundervestingMutation, DeleteOfferPauseEventFoundervestingMutationVariables> = gql`\n  mutation deleteOfferPauseEventFOUNDERVESTING($pauseEvent: FounderVestingOfferPauseEventCakeType!, $force: Boolean) {\n  deleteOfferPauseEventFounderVesting(pauseEvent: $pauseEvent, force: $force)\n}\n    `;\nexport type DeleteOfferPauseEventFoundervestingMutationFn = Apollo.MutationFunction<DeleteOfferPauseEventFoundervestingMutation, DeleteOfferPauseEventFoundervestingMutationVariables>;\n\n/**\n * __useDeleteOfferPauseEventFoundervestingMutation__\n *\n * To run a mutation, you first call `useDeleteOfferPauseEventFoundervestingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteOfferPauseEventFoundervestingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteOfferPauseEventFoundervestingMutation, { data, loading, error }] = useDeleteOfferPauseEventFoundervestingMutation({\n *   variables: {\n *      pauseEvent: // value for 'pauseEvent'\n *      force: // value for 'force'\n *   },\n * });\n */\nexport function useDeleteOfferPauseEventFoundervestingMutation(baseOptions?: Apollo.MutationHookOptions<DeleteOfferPauseEventFoundervestingMutation, DeleteOfferPauseEventFoundervestingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteOfferPauseEventFoundervestingMutation, DeleteOfferPauseEventFoundervestingMutationVariables>(DeleteOfferPauseEventFoundervestingDocument, options);\n      }\nexport type DeleteOfferPauseEventFoundervestingMutationHookResult = ReturnType<typeof useDeleteOfferPauseEventFoundervestingMutation>;\nexport type DeleteOfferPauseEventFoundervestingMutationResult = Apollo.MutationResult<DeleteOfferPauseEventFoundervestingMutation>;\nexport type DeleteOfferPauseEventFoundervestingMutationOptions = Apollo.BaseMutationOptions<DeleteOfferPauseEventFoundervestingMutation, DeleteOfferPauseEventFoundervestingMutationVariables>;\nexport const IssueSharesFounderVestingDocument: TypedDocumentNode<IssueSharesFounderVestingMutation, IssueSharesFounderVestingMutationVariables> = gql`\n  mutation issueSharesFounderVesting($issueSharesInput: IssueSharesInput!, $offerData: OfferInputType!) {\n  issueSharesFounderVesting(\n    issueSharesInput: $issueSharesInput\n    offerData: $offerData\n  )\n}\n    `;\nexport type IssueSharesFounderVestingMutationFn = Apollo.MutationFunction<IssueSharesFounderVestingMutation, IssueSharesFounderVestingMutationVariables>;\n\n/**\n * __useIssueSharesFounderVestingMutation__\n *\n * To run a mutation, you first call `useIssueSharesFounderVestingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useIssueSharesFounderVestingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [issueSharesFounderVestingMutation, { data, loading, error }] = useIssueSharesFounderVestingMutation({\n *   variables: {\n *      issueSharesInput: // value for 'issueSharesInput'\n *      offerData: // value for 'offerData'\n *   },\n * });\n */\nexport function useIssueSharesFounderVestingMutation(baseOptions?: Apollo.MutationHookOptions<IssueSharesFounderVestingMutation, IssueSharesFounderVestingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<IssueSharesFounderVestingMutation, IssueSharesFounderVestingMutationVariables>(IssueSharesFounderVestingDocument, options);\n      }\nexport type IssueSharesFounderVestingMutationHookResult = ReturnType<typeof useIssueSharesFounderVestingMutation>;\nexport type IssueSharesFounderVestingMutationResult = Apollo.MutationResult<IssueSharesFounderVestingMutation>;\nexport type IssueSharesFounderVestingMutationOptions = Apollo.BaseMutationOptions<IssueSharesFounderVestingMutation, IssueSharesFounderVestingMutationVariables>;\nexport const Update83bFormDownloadStatusDocument: TypedDocumentNode<Update83bFormDownloadStatusMutation, Update83bFormDownloadStatusMutationVariables> = gql`\n  mutation update83bFormDownloadStatus($offerId: FounderVestingOfferCakeType!) {\n  update83bFormDownloadStatus(offer: $offerId)\n}\n    `;\nexport type Update83bFormDownloadStatusMutationFn = Apollo.MutationFunction<Update83bFormDownloadStatusMutation, Update83bFormDownloadStatusMutationVariables>;\n\n/**\n * __useUpdate83bFormDownloadStatusMutation__\n *\n * To run a mutation, you first call `useUpdate83bFormDownloadStatusMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdate83bFormDownloadStatusMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [update83bFormDownloadStatusMutation, { data, loading, error }] = useUpdate83bFormDownloadStatusMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useUpdate83bFormDownloadStatusMutation(baseOptions?: Apollo.MutationHookOptions<Update83bFormDownloadStatusMutation, Update83bFormDownloadStatusMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<Update83bFormDownloadStatusMutation, Update83bFormDownloadStatusMutationVariables>(Update83bFormDownloadStatusDocument, options);\n      }\nexport type Update83bFormDownloadStatusMutationHookResult = ReturnType<typeof useUpdate83bFormDownloadStatusMutation>;\nexport type Update83bFormDownloadStatusMutationResult = Apollo.MutationResult<Update83bFormDownloadStatusMutation>;\nexport type Update83bFormDownloadStatusMutationOptions = Apollo.BaseMutationOptions<Update83bFormDownloadStatusMutation, Update83bFormDownloadStatusMutationVariables>;\nexport const OnOffAutoVestEmailsFounderVestingDocument: TypedDocumentNode<OnOffAutoVestEmailsFounderVestingMutation, OnOffAutoVestEmailsFounderVestingMutationVariables> = gql`\n  mutation onOffAutoVestEmailsFounderVesting($offers: [FounderVestingOfferCakeType!]!, $emailsOn: Boolean!) {\n  onOffAutoVestEmailsFounderVesting(offers: $offers, emailsOn: $emailsOn)\n}\n    `;\nexport type OnOffAutoVestEmailsFounderVestingMutationFn = Apollo.MutationFunction<OnOffAutoVestEmailsFounderVestingMutation, OnOffAutoVestEmailsFounderVestingMutationVariables>;\n\n/**\n * __useOnOffAutoVestEmailsFounderVestingMutation__\n *\n * To run a mutation, you first call `useOnOffAutoVestEmailsFounderVestingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useOnOffAutoVestEmailsFounderVestingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [onOffAutoVestEmailsFounderVestingMutation, { data, loading, error }] = useOnOffAutoVestEmailsFounderVestingMutation({\n *   variables: {\n *      offers: // value for 'offers'\n *      emailsOn: // value for 'emailsOn'\n *   },\n * });\n */\nexport function useOnOffAutoVestEmailsFounderVestingMutation(baseOptions?: Apollo.MutationHookOptions<OnOffAutoVestEmailsFounderVestingMutation, OnOffAutoVestEmailsFounderVestingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<OnOffAutoVestEmailsFounderVestingMutation, OnOffAutoVestEmailsFounderVestingMutationVariables>(OnOffAutoVestEmailsFounderVestingDocument, options);\n      }\nexport type OnOffAutoVestEmailsFounderVestingMutationHookResult = ReturnType<typeof useOnOffAutoVestEmailsFounderVestingMutation>;\nexport type OnOffAutoVestEmailsFounderVestingMutationResult = Apollo.MutationResult<OnOffAutoVestEmailsFounderVestingMutation>;\nexport type OnOffAutoVestEmailsFounderVestingMutationOptions = Apollo.BaseMutationOptions<OnOffAutoVestEmailsFounderVestingMutation, OnOffAutoVestEmailsFounderVestingMutationVariables>;\nexport const GetMessageAnalyticsDocument: TypedDocumentNode<GetMessageAnalyticsQuery, GetMessageAnalyticsQueryVariables> = gql`\n  query getMessageAnalytics($replyThread: CakeReplyThreadCakeType!, $page: PositiveInteger, $itemsPerPage: PositiveInteger) {\n  messageAnalytics(\n    replyThread: $replyThread\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    currentPage\n    count\n    pageData {\n      displayName\n      openCount\n      avatar\n      hasLoggedIn\n      reaction\n    }\n    messageId\n    uniqueOpenCount\n    allowReactions\n  }\n}\n    `;\n\n/**\n * __useGetMessageAnalyticsQuery__\n *\n * To run a query within a React component, call `useGetMessageAnalyticsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetMessageAnalyticsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetMessageAnalyticsQuery({\n *   variables: {\n *      replyThread: // value for 'replyThread'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetMessageAnalyticsQuery(baseOptions: Apollo.QueryHookOptions<GetMessageAnalyticsQuery, GetMessageAnalyticsQueryVariables> & ({ variables: GetMessageAnalyticsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetMessageAnalyticsQuery, GetMessageAnalyticsQueryVariables>(GetMessageAnalyticsDocument, options);\n      }\nexport function useGetMessageAnalyticsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetMessageAnalyticsQuery, GetMessageAnalyticsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetMessageAnalyticsQuery, GetMessageAnalyticsQueryVariables>(GetMessageAnalyticsDocument, options);\n        }\nexport function useGetMessageAnalyticsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetMessageAnalyticsQuery, GetMessageAnalyticsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetMessageAnalyticsQuery, GetMessageAnalyticsQueryVariables>(GetMessageAnalyticsDocument, options);\n        }\nexport type GetMessageAnalyticsQueryHookResult = ReturnType<typeof useGetMessageAnalyticsQuery>;\nexport type GetMessageAnalyticsLazyQueryHookResult = ReturnType<typeof useGetMessageAnalyticsLazyQuery>;\nexport type GetMessageAnalyticsSuspenseQueryHookResult = ReturnType<typeof useGetMessageAnalyticsSuspenseQuery>;\nexport type GetMessageAnalyticsQueryResult = Apollo.QueryResult<GetMessageAnalyticsQuery, GetMessageAnalyticsQueryVariables>;\nexport function refetchGetMessageAnalyticsQuery(variables: GetMessageAnalyticsQueryVariables) {\n      return { query: GetMessageAnalyticsDocument, variables: variables };\n    }\nexport const SendMessageDocument: TypedDocumentNode<SendMessageMutation, SendMessageMutationVariables> = gql`\n  mutation sendMessage($organisation: OrganisationCakeType!, $shareholderIdList: [ShareholderCakeType]!, $groupIdList: [CakeGroupCakeType]!, $fromShareholder: ShareholderCakeType, $body: CleanString!, $subject: CleanString!, $message: CakeMessageCakeType, $allowReactions: Boolean, $allowReplies: Boolean, $attachments: [DocumentCakeType], $rootMessage: CakeMessageCakeType, $replyThread: CakeReplyThreadCakeType) {\n  sendMessage(\n    organisation: $organisation\n    body: $body\n    subject: $subject\n    shareholders: $shareholderIdList\n    groups: $groupIdList\n    fromShareholder: $fromShareholder\n    message: $message\n    allowReactions: $allowReactions\n    allowReplies: $allowReplies\n    attachments: $attachments\n    rootMessage: $rootMessage\n    replyThread: $replyThread\n  ) {\n    messageId\n    replyThreadId\n  }\n}\n    `;\nexport type SendMessageMutationFn = Apollo.MutationFunction<SendMessageMutation, SendMessageMutationVariables>;\n\n/**\n * __useSendMessageMutation__\n *\n * To run a mutation, you first call `useSendMessageMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSendMessageMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [sendMessageMutation, { data, loading, error }] = useSendMessageMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      shareholderIdList: // value for 'shareholderIdList'\n *      groupIdList: // value for 'groupIdList'\n *      fromShareholder: // value for 'fromShareholder'\n *      body: // value for 'body'\n *      subject: // value for 'subject'\n *      message: // value for 'message'\n *      allowReactions: // value for 'allowReactions'\n *      allowReplies: // value for 'allowReplies'\n *      attachments: // value for 'attachments'\n *      rootMessage: // value for 'rootMessage'\n *      replyThread: // value for 'replyThread'\n *   },\n * });\n */\nexport function useSendMessageMutation(baseOptions?: Apollo.MutationHookOptions<SendMessageMutation, SendMessageMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SendMessageMutation, SendMessageMutationVariables>(SendMessageDocument, options);\n      }\nexport type SendMessageMutationHookResult = ReturnType<typeof useSendMessageMutation>;\nexport type SendMessageMutationResult = Apollo.MutationResult<SendMessageMutation>;\nexport type SendMessageMutationOptions = Apollo.BaseMutationOptions<SendMessageMutation, SendMessageMutationVariables>;\nexport const SaveMessageDocument: TypedDocumentNode<SaveMessageMutation, SaveMessageMutationVariables> = gql`\n  mutation saveMessage($organisation: OrganisationCakeType!, $shareholderIdList: [ShareholderCakeType]!, $groupIdList: [CakeGroupCakeType]!, $fromShareholder: ShareholderCakeType, $body: String!, $subject: String!, $message: CakeMessageCakeType, $allowReactions: Boolean, $allowReplies: Boolean, $attachments: [DocumentCakeType], $rootMessage: CakeMessageCakeType, $replyThread: CakeReplyThreadCakeType) {\n  saveMessage(\n    organisation: $organisation\n    body: $body\n    subject: $subject\n    shareholders: $shareholderIdList\n    groups: $groupIdList\n    fromShareholder: $fromShareholder\n    message: $message\n    allowReactions: $allowReactions\n    allowReplies: $allowReplies\n    attachments: $attachments\n    rootMessage: $rootMessage\n    replyThread: $replyThread\n  )\n}\n    `;\nexport type SaveMessageMutationFn = Apollo.MutationFunction<SaveMessageMutation, SaveMessageMutationVariables>;\n\n/**\n * __useSaveMessageMutation__\n *\n * To run a mutation, you first call `useSaveMessageMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSaveMessageMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [saveMessageMutation, { data, loading, error }] = useSaveMessageMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      shareholderIdList: // value for 'shareholderIdList'\n *      groupIdList: // value for 'groupIdList'\n *      fromShareholder: // value for 'fromShareholder'\n *      body: // value for 'body'\n *      subject: // value for 'subject'\n *      message: // value for 'message'\n *      allowReactions: // value for 'allowReactions'\n *      allowReplies: // value for 'allowReplies'\n *      attachments: // value for 'attachments'\n *      rootMessage: // value for 'rootMessage'\n *      replyThread: // value for 'replyThread'\n *   },\n * });\n */\nexport function useSaveMessageMutation(baseOptions?: Apollo.MutationHookOptions<SaveMessageMutation, SaveMessageMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SaveMessageMutation, SaveMessageMutationVariables>(SaveMessageDocument, options);\n      }\nexport type SaveMessageMutationHookResult = ReturnType<typeof useSaveMessageMutation>;\nexport type SaveMessageMutationResult = Apollo.MutationResult<SaveMessageMutation>;\nexport type SaveMessageMutationOptions = Apollo.BaseMutationOptions<SaveMessageMutation, SaveMessageMutationVariables>;\nexport const DeleteMessageDocument: TypedDocumentNode<DeleteMessageMutation, DeleteMessageMutationVariables> = gql`\n  mutation deleteMessage($message: CakeMessageCakeType!) {\n  deleteMessage(message: $message)\n}\n    `;\nexport type DeleteMessageMutationFn = Apollo.MutationFunction<DeleteMessageMutation, DeleteMessageMutationVariables>;\n\n/**\n * __useDeleteMessageMutation__\n *\n * To run a mutation, you first call `useDeleteMessageMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteMessageMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteMessageMutation, { data, loading, error }] = useDeleteMessageMutation({\n *   variables: {\n *      message: // value for 'message'\n *   },\n * });\n */\nexport function useDeleteMessageMutation(baseOptions?: Apollo.MutationHookOptions<DeleteMessageMutation, DeleteMessageMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteMessageMutation, DeleteMessageMutationVariables>(DeleteMessageDocument, options);\n      }\nexport type DeleteMessageMutationHookResult = ReturnType<typeof useDeleteMessageMutation>;\nexport type DeleteMessageMutationResult = Apollo.MutationResult<DeleteMessageMutation>;\nexport type DeleteMessageMutationOptions = Apollo.BaseMutationOptions<DeleteMessageMutation, DeleteMessageMutationVariables>;\nexport const UpdateMessageAnalyticsDocument: TypedDocumentNode<UpdateMessageAnalyticsMutation, UpdateMessageAnalyticsMutationVariables> = gql`\n  mutation updateMessageAnalytics($messageId: CakeMessageCakeType!) {\n  updateMessageAnalytics(message: $messageId)\n}\n    `;\nexport type UpdateMessageAnalyticsMutationFn = Apollo.MutationFunction<UpdateMessageAnalyticsMutation, UpdateMessageAnalyticsMutationVariables>;\n\n/**\n * __useUpdateMessageAnalyticsMutation__\n *\n * To run a mutation, you first call `useUpdateMessageAnalyticsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateMessageAnalyticsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateMessageAnalyticsMutation, { data, loading, error }] = useUpdateMessageAnalyticsMutation({\n *   variables: {\n *      messageId: // value for 'messageId'\n *   },\n * });\n */\nexport function useUpdateMessageAnalyticsMutation(baseOptions?: Apollo.MutationHookOptions<UpdateMessageAnalyticsMutation, UpdateMessageAnalyticsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateMessageAnalyticsMutation, UpdateMessageAnalyticsMutationVariables>(UpdateMessageAnalyticsDocument, options);\n      }\nexport type UpdateMessageAnalyticsMutationHookResult = ReturnType<typeof useUpdateMessageAnalyticsMutation>;\nexport type UpdateMessageAnalyticsMutationResult = Apollo.MutationResult<UpdateMessageAnalyticsMutation>;\nexport type UpdateMessageAnalyticsMutationOptions = Apollo.BaseMutationOptions<UpdateMessageAnalyticsMutation, UpdateMessageAnalyticsMutationVariables>;\nexport const ToggleMessageAllowRepliesDocument: TypedDocumentNode<ToggleMessageAllowRepliesMutation, ToggleMessageAllowRepliesMutationVariables> = gql`\n  mutation toggleMessageAllowReplies($message: CakeMessageCakeType!, $allowReplies: Boolean!) {\n  toggleMessageAllowReplies(message: $message, allowReplies: $allowReplies)\n}\n    `;\nexport type ToggleMessageAllowRepliesMutationFn = Apollo.MutationFunction<ToggleMessageAllowRepliesMutation, ToggleMessageAllowRepliesMutationVariables>;\n\n/**\n * __useToggleMessageAllowRepliesMutation__\n *\n * To run a mutation, you first call `useToggleMessageAllowRepliesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useToggleMessageAllowRepliesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [toggleMessageAllowRepliesMutation, { data, loading, error }] = useToggleMessageAllowRepliesMutation({\n *   variables: {\n *      message: // value for 'message'\n *      allowReplies: // value for 'allowReplies'\n *   },\n * });\n */\nexport function useToggleMessageAllowRepliesMutation(baseOptions?: Apollo.MutationHookOptions<ToggleMessageAllowRepliesMutation, ToggleMessageAllowRepliesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ToggleMessageAllowRepliesMutation, ToggleMessageAllowRepliesMutationVariables>(ToggleMessageAllowRepliesDocument, options);\n      }\nexport type ToggleMessageAllowRepliesMutationHookResult = ReturnType<typeof useToggleMessageAllowRepliesMutation>;\nexport type ToggleMessageAllowRepliesMutationResult = Apollo.MutationResult<ToggleMessageAllowRepliesMutation>;\nexport type ToggleMessageAllowRepliesMutationOptions = Apollo.BaseMutationOptions<ToggleMessageAllowRepliesMutation, ToggleMessageAllowRepliesMutationVariables>;\nexport const ToggleOrganisationAllowRepliesDocument: TypedDocumentNode<ToggleOrganisationAllowRepliesMutation, ToggleOrganisationAllowRepliesMutationVariables> = gql`\n  mutation toggleOrganisationAllowReplies($organisation: OrganisationCakeType!, $allowReplies: Boolean!) {\n  toggleOrganisationAllowReplies(\n    organisation: $organisation\n    allowReplies: $allowReplies\n  )\n}\n    `;\nexport type ToggleOrganisationAllowRepliesMutationFn = Apollo.MutationFunction<ToggleOrganisationAllowRepliesMutation, ToggleOrganisationAllowRepliesMutationVariables>;\n\n/**\n * __useToggleOrganisationAllowRepliesMutation__\n *\n * To run a mutation, you first call `useToggleOrganisationAllowRepliesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useToggleOrganisationAllowRepliesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [toggleOrganisationAllowRepliesMutation, { data, loading, error }] = useToggleOrganisationAllowRepliesMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      allowReplies: // value for 'allowReplies'\n *   },\n * });\n */\nexport function useToggleOrganisationAllowRepliesMutation(baseOptions?: Apollo.MutationHookOptions<ToggleOrganisationAllowRepliesMutation, ToggleOrganisationAllowRepliesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ToggleOrganisationAllowRepliesMutation, ToggleOrganisationAllowRepliesMutationVariables>(ToggleOrganisationAllowRepliesDocument, options);\n      }\nexport type ToggleOrganisationAllowRepliesMutationHookResult = ReturnType<typeof useToggleOrganisationAllowRepliesMutation>;\nexport type ToggleOrganisationAllowRepliesMutationResult = Apollo.MutationResult<ToggleOrganisationAllowRepliesMutation>;\nexport type ToggleOrganisationAllowRepliesMutationOptions = Apollo.BaseMutationOptions<ToggleOrganisationAllowRepliesMutation, ToggleOrganisationAllowRepliesMutationVariables>;\nexport const OrganisationInboxDocument: TypedDocumentNode<OrganisationInboxQuery, OrganisationInboxQueryVariables> = gql`\n  query organisationInbox($organisation: OrganisationCakeType!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!) {\n  organisationInbox(\n    organisation: $organisation\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    pageData {\n      id\n      organisationId\n      organisationName\n      avatarImage\n      avatarName\n      threadLength\n      created\n      subject\n      nRecipients\n      hasAttachments\n      hasUnreadMessages\n      lastMessageStatus\n    }\n  }\n  organisationAllowMessageReplies(organisation: $organisation)\n}\n    `;\n\n/**\n * __useOrganisationInboxQuery__\n *\n * To run a query within a React component, call `useOrganisationInboxQuery` and pass it any options that fit your needs.\n * When your component renders, `useOrganisationInboxQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOrganisationInboxQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useOrganisationInboxQuery(baseOptions: Apollo.QueryHookOptions<OrganisationInboxQuery, OrganisationInboxQueryVariables> & ({ variables: OrganisationInboxQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OrganisationInboxQuery, OrganisationInboxQueryVariables>(OrganisationInboxDocument, options);\n      }\nexport function useOrganisationInboxLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OrganisationInboxQuery, OrganisationInboxQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OrganisationInboxQuery, OrganisationInboxQueryVariables>(OrganisationInboxDocument, options);\n        }\nexport function useOrganisationInboxSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OrganisationInboxQuery, OrganisationInboxQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OrganisationInboxQuery, OrganisationInboxQueryVariables>(OrganisationInboxDocument, options);\n        }\nexport type OrganisationInboxQueryHookResult = ReturnType<typeof useOrganisationInboxQuery>;\nexport type OrganisationInboxLazyQueryHookResult = ReturnType<typeof useOrganisationInboxLazyQuery>;\nexport type OrganisationInboxSuspenseQueryHookResult = ReturnType<typeof useOrganisationInboxSuspenseQuery>;\nexport type OrganisationInboxQueryResult = Apollo.QueryResult<OrganisationInboxQuery, OrganisationInboxQueryVariables>;\nexport function refetchOrganisationInboxQuery(variables: OrganisationInboxQueryVariables) {\n      return { query: OrganisationInboxDocument, variables: variables };\n    }\nexport const OrganisationAllowMessageRepliesDocument: TypedDocumentNode<OrganisationAllowMessageRepliesQuery, OrganisationAllowMessageRepliesQueryVariables> = gql`\n  query organisationAllowMessageReplies($organisation: OrganisationCakeType!) {\n  organisationAllowMessageReplies(organisation: $organisation)\n}\n    `;\n\n/**\n * __useOrganisationAllowMessageRepliesQuery__\n *\n * To run a query within a React component, call `useOrganisationAllowMessageRepliesQuery` and pass it any options that fit your needs.\n * When your component renders, `useOrganisationAllowMessageRepliesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOrganisationAllowMessageRepliesQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useOrganisationAllowMessageRepliesQuery(baseOptions: Apollo.QueryHookOptions<OrganisationAllowMessageRepliesQuery, OrganisationAllowMessageRepliesQueryVariables> & ({ variables: OrganisationAllowMessageRepliesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OrganisationAllowMessageRepliesQuery, OrganisationAllowMessageRepliesQueryVariables>(OrganisationAllowMessageRepliesDocument, options);\n      }\nexport function useOrganisationAllowMessageRepliesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OrganisationAllowMessageRepliesQuery, OrganisationAllowMessageRepliesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OrganisationAllowMessageRepliesQuery, OrganisationAllowMessageRepliesQueryVariables>(OrganisationAllowMessageRepliesDocument, options);\n        }\nexport function useOrganisationAllowMessageRepliesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OrganisationAllowMessageRepliesQuery, OrganisationAllowMessageRepliesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OrganisationAllowMessageRepliesQuery, OrganisationAllowMessageRepliesQueryVariables>(OrganisationAllowMessageRepliesDocument, options);\n        }\nexport type OrganisationAllowMessageRepliesQueryHookResult = ReturnType<typeof useOrganisationAllowMessageRepliesQuery>;\nexport type OrganisationAllowMessageRepliesLazyQueryHookResult = ReturnType<typeof useOrganisationAllowMessageRepliesLazyQuery>;\nexport type OrganisationAllowMessageRepliesSuspenseQueryHookResult = ReturnType<typeof useOrganisationAllowMessageRepliesSuspenseQuery>;\nexport type OrganisationAllowMessageRepliesQueryResult = Apollo.QueryResult<OrganisationAllowMessageRepliesQuery, OrganisationAllowMessageRepliesQueryVariables>;\nexport function refetchOrganisationAllowMessageRepliesQuery(variables: OrganisationAllowMessageRepliesQueryVariables) {\n      return { query: OrganisationAllowMessageRepliesDocument, variables: variables };\n    }\nexport const OrganisationMessageThreadDocument: TypedDocumentNode<OrganisationMessageThreadQuery, OrganisationMessageThreadQueryVariables> = gql`\n  query organisationMessageThread($replyThreadId: CakeReplyThreadCakeType!, $page: PositiveInteger, $itemsPerPage: PositiveInteger, $isEdit: Boolean = false, $inReply: Boolean = false) {\n  organisationMessageThread(replyThread: $replyThreadId) {\n    id\n    participants @include(if: $inReply) {\n      id\n      displayName\n      avatar\n    }\n    replyingShareholders(isCompany: true) {\n      id\n      displayName\n      avatar\n    }\n    rootMessage {\n      replyThread {\n        id\n      }\n      draft @include(if: $isEdit) {\n        groups {\n          name\n          id\n        }\n        shareholders {\n          name\n          id\n        }\n      }\n      allowReplies\n      allowReactions\n      reactionAggregates {\n        reaction\n        count\n        stakeholders\n      }\n      id\n      created\n      subject\n      body\n      bodyParsed\n      isSeen(isCompany: true)\n      isDraft\n      attachments {\n        id\n        name\n        modified\n        extension\n      }\n      user {\n        firstName\n        lastName\n        picture\n      }\n      organisation {\n        id\n        name\n        logo\n      }\n    }\n    messages: organisationMessages(page: $page, itemsPerPage: $itemsPerPage) {\n      pageData {\n        created\n        id\n        subject\n        body\n        isDraft\n        isSeen(isCompany: false)\n        isCompanyMessage\n        organisation {\n          id\n          name\n          logo: logoImageLink\n        }\n        attachments {\n          id\n          name\n          modified\n          extension\n        }\n        user {\n          firstName\n          lastName\n          picture\n        }\n      }\n      currentPage\n      count\n    }\n  }\n}\n    `;\n\n/**\n * __useOrganisationMessageThreadQuery__\n *\n * To run a query within a React component, call `useOrganisationMessageThreadQuery` and pass it any options that fit your needs.\n * When your component renders, `useOrganisationMessageThreadQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOrganisationMessageThreadQuery({\n *   variables: {\n *      replyThreadId: // value for 'replyThreadId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      isEdit: // value for 'isEdit'\n *      inReply: // value for 'inReply'\n *   },\n * });\n */\nexport function useOrganisationMessageThreadQuery(baseOptions: Apollo.QueryHookOptions<OrganisationMessageThreadQuery, OrganisationMessageThreadQueryVariables> & ({ variables: OrganisationMessageThreadQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OrganisationMessageThreadQuery, OrganisationMessageThreadQueryVariables>(OrganisationMessageThreadDocument, options);\n      }\nexport function useOrganisationMessageThreadLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OrganisationMessageThreadQuery, OrganisationMessageThreadQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OrganisationMessageThreadQuery, OrganisationMessageThreadQueryVariables>(OrganisationMessageThreadDocument, options);\n        }\nexport function useOrganisationMessageThreadSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OrganisationMessageThreadQuery, OrganisationMessageThreadQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OrganisationMessageThreadQuery, OrganisationMessageThreadQueryVariables>(OrganisationMessageThreadDocument, options);\n        }\nexport type OrganisationMessageThreadQueryHookResult = ReturnType<typeof useOrganisationMessageThreadQuery>;\nexport type OrganisationMessageThreadLazyQueryHookResult = ReturnType<typeof useOrganisationMessageThreadLazyQuery>;\nexport type OrganisationMessageThreadSuspenseQueryHookResult = ReturnType<typeof useOrganisationMessageThreadSuspenseQuery>;\nexport type OrganisationMessageThreadQueryResult = Apollo.QueryResult<OrganisationMessageThreadQuery, OrganisationMessageThreadQueryVariables>;\nexport function refetchOrganisationMessageThreadQuery(variables: OrganisationMessageThreadQueryVariables) {\n      return { query: OrganisationMessageThreadDocument, variables: variables };\n    }\nexport const GetShareholdersForAutocompleteDocument: TypedDocumentNode<GetShareholdersForAutocompleteQuery, GetShareholdersForAutocompleteQueryVariables> = gql`\n  query getShareholdersForAutocomplete($organisationId: UUID!, $page: Int!, $itemsPerPage: Int!, $search: String, $shareholderIdsToExclude: [UUID]) {\n  paginatedShareholders(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    search: $search\n    excludeByIds: $shareholderIdsToExclude\n  ) {\n    count\n    currentPage\n    pageData {\n      id\n      displayName\n      avatar\n      investorData {\n        email\n      }\n      employeeData {\n        role\n        level\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetShareholdersForAutocompleteQuery__\n *\n * To run a query within a React component, call `useGetShareholdersForAutocompleteQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetShareholdersForAutocompleteQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetShareholdersForAutocompleteQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      search: // value for 'search'\n *      shareholderIdsToExclude: // value for 'shareholderIdsToExclude'\n *   },\n * });\n */\nexport function useGetShareholdersForAutocompleteQuery(baseOptions: Apollo.QueryHookOptions<GetShareholdersForAutocompleteQuery, GetShareholdersForAutocompleteQueryVariables> & ({ variables: GetShareholdersForAutocompleteQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetShareholdersForAutocompleteQuery, GetShareholdersForAutocompleteQueryVariables>(GetShareholdersForAutocompleteDocument, options);\n      }\nexport function useGetShareholdersForAutocompleteLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetShareholdersForAutocompleteQuery, GetShareholdersForAutocompleteQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetShareholdersForAutocompleteQuery, GetShareholdersForAutocompleteQueryVariables>(GetShareholdersForAutocompleteDocument, options);\n        }\nexport function useGetShareholdersForAutocompleteSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetShareholdersForAutocompleteQuery, GetShareholdersForAutocompleteQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetShareholdersForAutocompleteQuery, GetShareholdersForAutocompleteQueryVariables>(GetShareholdersForAutocompleteDocument, options);\n        }\nexport type GetShareholdersForAutocompleteQueryHookResult = ReturnType<typeof useGetShareholdersForAutocompleteQuery>;\nexport type GetShareholdersForAutocompleteLazyQueryHookResult = ReturnType<typeof useGetShareholdersForAutocompleteLazyQuery>;\nexport type GetShareholdersForAutocompleteSuspenseQueryHookResult = ReturnType<typeof useGetShareholdersForAutocompleteSuspenseQuery>;\nexport type GetShareholdersForAutocompleteQueryResult = Apollo.QueryResult<GetShareholdersForAutocompleteQuery, GetShareholdersForAutocompleteQueryVariables>;\nexport function refetchGetShareholdersForAutocompleteQuery(variables: GetShareholdersForAutocompleteQueryVariables) {\n      return { query: GetShareholdersForAutocompleteDocument, variables: variables };\n    }\nexport const CreateEquityModelDocument: TypedDocumentNode<CreateEquityModelMutation, CreateEquityModelMutationVariables> = gql`\n  mutation createEquityModel($organisation: OrganisationCakeType!, $name: CleanString!, $modelData: EquityModelDataInputType!, $conversionMethodology: CleanString) {\n  createEquityModel(\n    organisation: $organisation\n    name: $name\n    modelData: $modelData\n    conversionMethodology: $conversionMethodology\n  )\n}\n    `;\nexport type CreateEquityModelMutationFn = Apollo.MutationFunction<CreateEquityModelMutation, CreateEquityModelMutationVariables>;\n\n/**\n * __useCreateEquityModelMutation__\n *\n * To run a mutation, you first call `useCreateEquityModelMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateEquityModelMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createEquityModelMutation, { data, loading, error }] = useCreateEquityModelMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      name: // value for 'name'\n *      modelData: // value for 'modelData'\n *      conversionMethodology: // value for 'conversionMethodology'\n *   },\n * });\n */\nexport function useCreateEquityModelMutation(baseOptions?: Apollo.MutationHookOptions<CreateEquityModelMutation, CreateEquityModelMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateEquityModelMutation, CreateEquityModelMutationVariables>(CreateEquityModelDocument, options);\n      }\nexport type CreateEquityModelMutationHookResult = ReturnType<typeof useCreateEquityModelMutation>;\nexport type CreateEquityModelMutationResult = Apollo.MutationResult<CreateEquityModelMutation>;\nexport type CreateEquityModelMutationOptions = Apollo.BaseMutationOptions<CreateEquityModelMutation, CreateEquityModelMutationVariables>;\nexport const EditEquityModelDocument: TypedDocumentNode<EditEquityModelMutation, EditEquityModelMutationVariables> = gql`\n  mutation editEquityModel($equityModel: EquityModelCakeType!, $name: CleanString!, $modelData: EquityModelDataInputType!, $conversionMethodology: CleanString) {\n  editEquityModel(\n    equityModel: $equityModel\n    name: $name\n    modelData: $modelData\n    conversionMethodology: $conversionMethodology\n  )\n}\n    `;\nexport type EditEquityModelMutationFn = Apollo.MutationFunction<EditEquityModelMutation, EditEquityModelMutationVariables>;\n\n/**\n * __useEditEquityModelMutation__\n *\n * To run a mutation, you first call `useEditEquityModelMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditEquityModelMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editEquityModelMutation, { data, loading, error }] = useEditEquityModelMutation({\n *   variables: {\n *      equityModel: // value for 'equityModel'\n *      name: // value for 'name'\n *      modelData: // value for 'modelData'\n *      conversionMethodology: // value for 'conversionMethodology'\n *   },\n * });\n */\nexport function useEditEquityModelMutation(baseOptions?: Apollo.MutationHookOptions<EditEquityModelMutation, EditEquityModelMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditEquityModelMutation, EditEquityModelMutationVariables>(EditEquityModelDocument, options);\n      }\nexport type EditEquityModelMutationHookResult = ReturnType<typeof useEditEquityModelMutation>;\nexport type EditEquityModelMutationResult = Apollo.MutationResult<EditEquityModelMutation>;\nexport type EditEquityModelMutationOptions = Apollo.BaseMutationOptions<EditEquityModelMutation, EditEquityModelMutationVariables>;\nexport const DeleteEquityModelDocument: TypedDocumentNode<DeleteEquityModelMutation, DeleteEquityModelMutationVariables> = gql`\n  mutation deleteEquityModel($equityModel: EquityModelCakeType!) {\n  deleteEquityModel(equityModel: $equityModel)\n}\n    `;\nexport type DeleteEquityModelMutationFn = Apollo.MutationFunction<DeleteEquityModelMutation, DeleteEquityModelMutationVariables>;\n\n/**\n * __useDeleteEquityModelMutation__\n *\n * To run a mutation, you first call `useDeleteEquityModelMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteEquityModelMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteEquityModelMutation, { data, loading, error }] = useDeleteEquityModelMutation({\n *   variables: {\n *      equityModel: // value for 'equityModel'\n *   },\n * });\n */\nexport function useDeleteEquityModelMutation(baseOptions?: Apollo.MutationHookOptions<DeleteEquityModelMutation, DeleteEquityModelMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteEquityModelMutation, DeleteEquityModelMutationVariables>(DeleteEquityModelDocument, options);\n      }\nexport type DeleteEquityModelMutationHookResult = ReturnType<typeof useDeleteEquityModelMutation>;\nexport type DeleteEquityModelMutationResult = Apollo.MutationResult<DeleteEquityModelMutation>;\nexport type DeleteEquityModelMutationOptions = Apollo.BaseMutationOptions<DeleteEquityModelMutation, DeleteEquityModelMutationVariables>;\nexport const EquityModelsDocument: TypedDocumentNode<EquityModelsQuery, EquityModelsQueryVariables> = gql`\n  query equityModels($organisation: OrganisationCakeType!) {\n  equityModels(organisation: $organisation) {\n    id\n    name\n    modified\n    modelData {\n      rounds {\n        equityRound\n        roundType\n        proposedValuation\n        investmentValue\n        investors {\n          name\n          investment\n        }\n        topUpOptionPoolPrct\n        convertNotes\n        roundMethodology\n        topUpSequence\n      }\n      notes {\n        investorName\n        principalIncludingInterest\n        valuationCap\n        discountRate\n        convertOnRound\n      }\n    }\n    conversionMethodology\n  }\n}\n    `;\n\n/**\n * __useEquityModelsQuery__\n *\n * To run a query within a React component, call `useEquityModelsQuery` and pass it any options that fit your needs.\n * When your component renders, `useEquityModelsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useEquityModelsQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useEquityModelsQuery(baseOptions: Apollo.QueryHookOptions<EquityModelsQuery, EquityModelsQueryVariables> & ({ variables: EquityModelsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<EquityModelsQuery, EquityModelsQueryVariables>(EquityModelsDocument, options);\n      }\nexport function useEquityModelsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<EquityModelsQuery, EquityModelsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<EquityModelsQuery, EquityModelsQueryVariables>(EquityModelsDocument, options);\n        }\nexport function useEquityModelsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<EquityModelsQuery, EquityModelsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<EquityModelsQuery, EquityModelsQueryVariables>(EquityModelsDocument, options);\n        }\nexport type EquityModelsQueryHookResult = ReturnType<typeof useEquityModelsQuery>;\nexport type EquityModelsLazyQueryHookResult = ReturnType<typeof useEquityModelsLazyQuery>;\nexport type EquityModelsSuspenseQueryHookResult = ReturnType<typeof useEquityModelsSuspenseQuery>;\nexport type EquityModelsQueryResult = Apollo.QueryResult<EquityModelsQuery, EquityModelsQueryVariables>;\nexport function refetchEquityModelsQuery(variables: EquityModelsQueryVariables) {\n      return { query: EquityModelsDocument, variables: variables };\n    }\nexport const NotesOffersDocument: TypedDocumentNode<NotesOffersQuery, NotesOffersQueryVariables> = gql`\n  query notesOffers($organisation: OrganisationCakeType!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $noteType: NoteType, $sort: [CleanString!], $filters: [ListFilterType!], $search: String) {\n  notesOffers(\n    organisation: $organisation\n    page: $page\n    itemsPerPage: $itemsPerPage\n    noteType: $noteType\n    sort: $sort\n    filters: $filters\n    search: $search\n  ) {\n    count\n    shareholderCount\n    notSignedUpCount\n    currentPage\n    pageData {\n      id\n      roundName\n      noteType\n      contractId\n      shareholderId\n      shareholderDisplayName\n      shareholderSecondaryName\n      shareholderAvatar\n      shareholderHasLoggedIn\n      shareholderConsideredInvited\n      shEmail\n      stakeholderType: shareholderType\n      isTrust: shareholderIsTrust\n      issueDate\n      principal\n      discountRate\n      valuationCap\n      resolutionDate\n      maturityDate\n      interestRate\n      softStatus\n    }\n  }\n}\n    `;\n\n/**\n * __useNotesOffersQuery__\n *\n * To run a query within a React component, call `useNotesOffersQuery` and pass it any options that fit your needs.\n * When your component renders, `useNotesOffersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useNotesOffersQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      noteType: // value for 'noteType'\n *      sort: // value for 'sort'\n *      filters: // value for 'filters'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useNotesOffersQuery(baseOptions: Apollo.QueryHookOptions<NotesOffersQuery, NotesOffersQueryVariables> & ({ variables: NotesOffersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<NotesOffersQuery, NotesOffersQueryVariables>(NotesOffersDocument, options);\n      }\nexport function useNotesOffersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<NotesOffersQuery, NotesOffersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<NotesOffersQuery, NotesOffersQueryVariables>(NotesOffersDocument, options);\n        }\nexport function useNotesOffersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<NotesOffersQuery, NotesOffersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<NotesOffersQuery, NotesOffersQueryVariables>(NotesOffersDocument, options);\n        }\nexport type NotesOffersQueryHookResult = ReturnType<typeof useNotesOffersQuery>;\nexport type NotesOffersLazyQueryHookResult = ReturnType<typeof useNotesOffersLazyQuery>;\nexport type NotesOffersSuspenseQueryHookResult = ReturnType<typeof useNotesOffersSuspenseQuery>;\nexport type NotesOffersQueryResult = Apollo.QueryResult<NotesOffersQuery, NotesOffersQueryVariables>;\nexport function refetchNotesOffersQuery(variables: NotesOffersQueryVariables) {\n      return { query: NotesOffersDocument, variables: variables };\n    }\nexport const NotesOfferDocument: TypedDocumentNode<NotesOfferQuery, NotesOfferQueryVariables> = gql`\n  query notesOffer($notesOffer: NotesRoundOfferCakeType!) {\n  notesOffer(notesOffer: $notesOffer) {\n    id\n    modified\n    noteType\n    status\n    principal\n    discountRate\n    valuationCap\n    maturityDate\n    interestRate\n    requireWitness\n    note {\n      resolution\n      resolutionDate\n      issueDate\n    }\n    contractTemplate {\n      id\n      name\n      contractLink\n    }\n    shareholder {\n      id\n      displayName\n      investorData {\n        email\n      }\n    }\n    contract {\n      id\n      name\n      contractType\n      extension\n      signatures {\n        name\n        email\n        status\n        extra\n      }\n    }\n    notesRound {\n      id\n      name\n    }\n    payment {\n      ... on AuPaymentDetailsType {\n        accountName\n        accountNumber\n        bsb\n        reference\n        isTrustAccount\n      }\n      ... on SgPaymentDetailsType {\n        accountName\n        accountNumber\n        swiftCode\n        bankCode\n        branchCode\n      }\n      ... on FallbackPaymentDetailsType {\n        details\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useNotesOfferQuery__\n *\n * To run a query within a React component, call `useNotesOfferQuery` and pass it any options that fit your needs.\n * When your component renders, `useNotesOfferQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useNotesOfferQuery({\n *   variables: {\n *      notesOffer: // value for 'notesOffer'\n *   },\n * });\n */\nexport function useNotesOfferQuery(baseOptions: Apollo.QueryHookOptions<NotesOfferQuery, NotesOfferQueryVariables> & ({ variables: NotesOfferQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<NotesOfferQuery, NotesOfferQueryVariables>(NotesOfferDocument, options);\n      }\nexport function useNotesOfferLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<NotesOfferQuery, NotesOfferQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<NotesOfferQuery, NotesOfferQueryVariables>(NotesOfferDocument, options);\n        }\nexport function useNotesOfferSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<NotesOfferQuery, NotesOfferQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<NotesOfferQuery, NotesOfferQueryVariables>(NotesOfferDocument, options);\n        }\nexport type NotesOfferQueryHookResult = ReturnType<typeof useNotesOfferQuery>;\nexport type NotesOfferLazyQueryHookResult = ReturnType<typeof useNotesOfferLazyQuery>;\nexport type NotesOfferSuspenseQueryHookResult = ReturnType<typeof useNotesOfferSuspenseQuery>;\nexport type NotesOfferQueryResult = Apollo.QueryResult<NotesOfferQuery, NotesOfferQueryVariables>;\nexport function refetchNotesOfferQuery(variables: NotesOfferQueryVariables) {\n      return { query: NotesOfferDocument, variables: variables };\n    }\nexport const GetNoteDocument: TypedDocumentNode<GetNoteQuery, GetNoteQueryVariables> = gql`\n  query getNote($noteId: NoteCakeType!) {\n  note(note: $noteId) {\n    id\n    resolution\n    noteType: type\n    principal\n    discountRate\n    maturityDate\n    interestRate\n    issueDate\n    valuationCap\n    shareholder {\n      displayName\n    }\n  }\n}\n    `;\n\n/**\n * __useGetNoteQuery__\n *\n * To run a query within a React component, call `useGetNoteQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetNoteQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetNoteQuery({\n *   variables: {\n *      noteId: // value for 'noteId'\n *   },\n * });\n */\nexport function useGetNoteQuery(baseOptions: Apollo.QueryHookOptions<GetNoteQuery, GetNoteQueryVariables> & ({ variables: GetNoteQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetNoteQuery, GetNoteQueryVariables>(GetNoteDocument, options);\n      }\nexport function useGetNoteLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNoteQuery, GetNoteQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetNoteQuery, GetNoteQueryVariables>(GetNoteDocument, options);\n        }\nexport function useGetNoteSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetNoteQuery, GetNoteQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetNoteQuery, GetNoteQueryVariables>(GetNoteDocument, options);\n        }\nexport type GetNoteQueryHookResult = ReturnType<typeof useGetNoteQuery>;\nexport type GetNoteLazyQueryHookResult = ReturnType<typeof useGetNoteLazyQuery>;\nexport type GetNoteSuspenseQueryHookResult = ReturnType<typeof useGetNoteSuspenseQuery>;\nexport type GetNoteQueryResult = Apollo.QueryResult<GetNoteQuery, GetNoteQueryVariables>;\nexport function refetchGetNoteQuery(variables: GetNoteQueryVariables) {\n      return { query: GetNoteDocument, variables: variables };\n    }\nexport const RepayNoteDocument: TypedDocumentNode<RepayNoteMutation, RepayNoteMutationVariables> = gql`\n  mutation repayNote($noteId: UUID!) {\n  repayNote(noteId: $noteId) {\n    ok\n  }\n}\n    `;\nexport type RepayNoteMutationFn = Apollo.MutationFunction<RepayNoteMutation, RepayNoteMutationVariables>;\n\n/**\n * __useRepayNoteMutation__\n *\n * To run a mutation, you first call `useRepayNoteMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRepayNoteMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [repayNoteMutation, { data, loading, error }] = useRepayNoteMutation({\n *   variables: {\n *      noteId: // value for 'noteId'\n *   },\n * });\n */\nexport function useRepayNoteMutation(baseOptions?: Apollo.MutationHookOptions<RepayNoteMutation, RepayNoteMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RepayNoteMutation, RepayNoteMutationVariables>(RepayNoteDocument, options);\n      }\nexport type RepayNoteMutationHookResult = ReturnType<typeof useRepayNoteMutation>;\nexport type RepayNoteMutationResult = Apollo.MutationResult<RepayNoteMutation>;\nexport type RepayNoteMutationOptions = Apollo.BaseMutationOptions<RepayNoteMutation, RepayNoteMutationVariables>;\nexport const GetStakeholdersToAddNoteDocument: TypedDocumentNode<GetStakeholdersToAddNoteQuery, GetStakeholdersToAddNoteQueryVariables> = gql`\n  query getStakeholdersToAddNote($organisationId: UUID!, $page: Int!, $itemsPerPage: Int!, $search: String) {\n  paginatedShareholders(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    search: $search\n  ) {\n    count\n    currentPage\n    pageData {\n      id\n      displayName\n      avatar\n      investorData {\n        email\n      }\n      employeeData {\n        role\n        level\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetStakeholdersToAddNoteQuery__\n *\n * To run a query within a React component, call `useGetStakeholdersToAddNoteQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetStakeholdersToAddNoteQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetStakeholdersToAddNoteQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetStakeholdersToAddNoteQuery(baseOptions: Apollo.QueryHookOptions<GetStakeholdersToAddNoteQuery, GetStakeholdersToAddNoteQueryVariables> & ({ variables: GetStakeholdersToAddNoteQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetStakeholdersToAddNoteQuery, GetStakeholdersToAddNoteQueryVariables>(GetStakeholdersToAddNoteDocument, options);\n      }\nexport function useGetStakeholdersToAddNoteLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetStakeholdersToAddNoteQuery, GetStakeholdersToAddNoteQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetStakeholdersToAddNoteQuery, GetStakeholdersToAddNoteQueryVariables>(GetStakeholdersToAddNoteDocument, options);\n        }\nexport function useGetStakeholdersToAddNoteSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetStakeholdersToAddNoteQuery, GetStakeholdersToAddNoteQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetStakeholdersToAddNoteQuery, GetStakeholdersToAddNoteQueryVariables>(GetStakeholdersToAddNoteDocument, options);\n        }\nexport type GetStakeholdersToAddNoteQueryHookResult = ReturnType<typeof useGetStakeholdersToAddNoteQuery>;\nexport type GetStakeholdersToAddNoteLazyQueryHookResult = ReturnType<typeof useGetStakeholdersToAddNoteLazyQuery>;\nexport type GetStakeholdersToAddNoteSuspenseQueryHookResult = ReturnType<typeof useGetStakeholdersToAddNoteSuspenseQuery>;\nexport type GetStakeholdersToAddNoteQueryResult = Apollo.QueryResult<GetStakeholdersToAddNoteQuery, GetStakeholdersToAddNoteQueryVariables>;\nexport function refetchGetStakeholdersToAddNoteQuery(variables: GetStakeholdersToAddNoteQueryVariables) {\n      return { query: GetStakeholdersToAddNoteDocument, variables: variables };\n    }\nexport const GetNotesRoundToAddNoteDocument: TypedDocumentNode<GetNotesRoundToAddNoteQuery, GetNotesRoundToAddNoteQueryVariables> = gql`\n  query getNotesRoundToAddNote($organisation: OrganisationCakeType!) {\n  notesRounds(organisation: $organisation) {\n    id\n    name\n  }\n}\n    `;\n\n/**\n * __useGetNotesRoundToAddNoteQuery__\n *\n * To run a query within a React component, call `useGetNotesRoundToAddNoteQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetNotesRoundToAddNoteQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetNotesRoundToAddNoteQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useGetNotesRoundToAddNoteQuery(baseOptions: Apollo.QueryHookOptions<GetNotesRoundToAddNoteQuery, GetNotesRoundToAddNoteQueryVariables> & ({ variables: GetNotesRoundToAddNoteQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetNotesRoundToAddNoteQuery, GetNotesRoundToAddNoteQueryVariables>(GetNotesRoundToAddNoteDocument, options);\n      }\nexport function useGetNotesRoundToAddNoteLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNotesRoundToAddNoteQuery, GetNotesRoundToAddNoteQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetNotesRoundToAddNoteQuery, GetNotesRoundToAddNoteQueryVariables>(GetNotesRoundToAddNoteDocument, options);\n        }\nexport function useGetNotesRoundToAddNoteSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetNotesRoundToAddNoteQuery, GetNotesRoundToAddNoteQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetNotesRoundToAddNoteQuery, GetNotesRoundToAddNoteQueryVariables>(GetNotesRoundToAddNoteDocument, options);\n        }\nexport type GetNotesRoundToAddNoteQueryHookResult = ReturnType<typeof useGetNotesRoundToAddNoteQuery>;\nexport type GetNotesRoundToAddNoteLazyQueryHookResult = ReturnType<typeof useGetNotesRoundToAddNoteLazyQuery>;\nexport type GetNotesRoundToAddNoteSuspenseQueryHookResult = ReturnType<typeof useGetNotesRoundToAddNoteSuspenseQuery>;\nexport type GetNotesRoundToAddNoteQueryResult = Apollo.QueryResult<GetNotesRoundToAddNoteQuery, GetNotesRoundToAddNoteQueryVariables>;\nexport function refetchGetNotesRoundToAddNoteQuery(variables: GetNotesRoundToAddNoteQueryVariables) {\n      return { query: GetNotesRoundToAddNoteDocument, variables: variables };\n    }\nexport const GetNotesRoundsNamesDocument: TypedDocumentNode<GetNotesRoundsNamesQuery, GetNotesRoundsNamesQueryVariables> = gql`\n  query getNotesRoundsNames($organisation: OrganisationCakeType!, $search: String) {\n  notesRoundsNames(\n    organisation: $organisation\n    page: 1\n    itemsPerPage: 1000\n    search: $search\n  ) {\n    pageData\n  }\n}\n    `;\n\n/**\n * __useGetNotesRoundsNamesQuery__\n *\n * To run a query within a React component, call `useGetNotesRoundsNamesQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetNotesRoundsNamesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetNotesRoundsNamesQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetNotesRoundsNamesQuery(baseOptions: Apollo.QueryHookOptions<GetNotesRoundsNamesQuery, GetNotesRoundsNamesQueryVariables> & ({ variables: GetNotesRoundsNamesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetNotesRoundsNamesQuery, GetNotesRoundsNamesQueryVariables>(GetNotesRoundsNamesDocument, options);\n      }\nexport function useGetNotesRoundsNamesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNotesRoundsNamesQuery, GetNotesRoundsNamesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetNotesRoundsNamesQuery, GetNotesRoundsNamesQueryVariables>(GetNotesRoundsNamesDocument, options);\n        }\nexport function useGetNotesRoundsNamesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetNotesRoundsNamesQuery, GetNotesRoundsNamesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetNotesRoundsNamesQuery, GetNotesRoundsNamesQueryVariables>(GetNotesRoundsNamesDocument, options);\n        }\nexport type GetNotesRoundsNamesQueryHookResult = ReturnType<typeof useGetNotesRoundsNamesQuery>;\nexport type GetNotesRoundsNamesLazyQueryHookResult = ReturnType<typeof useGetNotesRoundsNamesLazyQuery>;\nexport type GetNotesRoundsNamesSuspenseQueryHookResult = ReturnType<typeof useGetNotesRoundsNamesSuspenseQuery>;\nexport type GetNotesRoundsNamesQueryResult = Apollo.QueryResult<GetNotesRoundsNamesQuery, GetNotesRoundsNamesQueryVariables>;\nexport function refetchGetNotesRoundsNamesQuery(variables: GetNotesRoundsNamesQueryVariables) {\n      return { query: GetNotesRoundsNamesDocument, variables: variables };\n    }\nexport const GetNotesRoundsDocument: TypedDocumentNode<GetNotesRoundsQuery, GetNotesRoundsQueryVariables> = gql`\n  query getNotesRounds($organisation: OrganisationCakeType!) {\n  notesRounds(organisation: $organisation, page: 1, itemsPerPage: 1000) {\n    id\n    name\n    noteType\n    contractTemplate {\n      id\n    }\n  }\n}\n    `;\n\n/**\n * __useGetNotesRoundsQuery__\n *\n * To run a query within a React component, call `useGetNotesRoundsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetNotesRoundsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetNotesRoundsQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useGetNotesRoundsQuery(baseOptions: Apollo.QueryHookOptions<GetNotesRoundsQuery, GetNotesRoundsQueryVariables> & ({ variables: GetNotesRoundsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetNotesRoundsQuery, GetNotesRoundsQueryVariables>(GetNotesRoundsDocument, options);\n      }\nexport function useGetNotesRoundsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNotesRoundsQuery, GetNotesRoundsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetNotesRoundsQuery, GetNotesRoundsQueryVariables>(GetNotesRoundsDocument, options);\n        }\nexport function useGetNotesRoundsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetNotesRoundsQuery, GetNotesRoundsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetNotesRoundsQuery, GetNotesRoundsQueryVariables>(GetNotesRoundsDocument, options);\n        }\nexport type GetNotesRoundsQueryHookResult = ReturnType<typeof useGetNotesRoundsQuery>;\nexport type GetNotesRoundsLazyQueryHookResult = ReturnType<typeof useGetNotesRoundsLazyQuery>;\nexport type GetNotesRoundsSuspenseQueryHookResult = ReturnType<typeof useGetNotesRoundsSuspenseQuery>;\nexport type GetNotesRoundsQueryResult = Apollo.QueryResult<GetNotesRoundsQuery, GetNotesRoundsQueryVariables>;\nexport function refetchGetNotesRoundsQuery(variables: GetNotesRoundsQueryVariables) {\n      return { query: GetNotesRoundsDocument, variables: variables };\n    }\nexport const CreateNotesOfferDocument: TypedDocumentNode<CreateNotesOfferMutation, CreateNotesOfferMutationVariables> = gql`\n  mutation createNotesOffer($organisation: OrganisationCakeType!, $noteType: String!, $principal: CakeDecimal!, $discountRate: CakeDecimal, $valuationCap: CakeDecimal, $interest: Interest, $maturityDate: Date, $round: String, $contractTemplate: DocumentCakeType, $contractTemplateFromMaster: Boolean, $sharetype: SharetypeCakeType, $existingShareholder: ShareholderCakeType, $newShareholder: InvestorAndEmployeeDataInput) {\n  createNotesOffer(\n    organisation: $organisation\n    noteType: $noteType\n    principal: $principal\n    discountRate: $discountRate\n    valuationCap: $valuationCap\n    interest: $interest\n    maturityDate: $maturityDate\n    round: $round\n    contractTemplate: $contractTemplate\n    contractTemplateFromMaster: $contractTemplateFromMaster\n    sharetype: $sharetype\n    existingShareholder: $existingShareholder\n    newShareholder: $newShareholder\n  ) {\n    id\n  }\n}\n    `;\nexport type CreateNotesOfferMutationFn = Apollo.MutationFunction<CreateNotesOfferMutation, CreateNotesOfferMutationVariables>;\n\n/**\n * __useCreateNotesOfferMutation__\n *\n * To run a mutation, you first call `useCreateNotesOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateNotesOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createNotesOfferMutation, { data, loading, error }] = useCreateNotesOfferMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      noteType: // value for 'noteType'\n *      principal: // value for 'principal'\n *      discountRate: // value for 'discountRate'\n *      valuationCap: // value for 'valuationCap'\n *      interest: // value for 'interest'\n *      maturityDate: // value for 'maturityDate'\n *      round: // value for 'round'\n *      contractTemplate: // value for 'contractTemplate'\n *      contractTemplateFromMaster: // value for 'contractTemplateFromMaster'\n *      sharetype: // value for 'sharetype'\n *      existingShareholder: // value for 'existingShareholder'\n *      newShareholder: // value for 'newShareholder'\n *   },\n * });\n */\nexport function useCreateNotesOfferMutation(baseOptions?: Apollo.MutationHookOptions<CreateNotesOfferMutation, CreateNotesOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateNotesOfferMutation, CreateNotesOfferMutationVariables>(CreateNotesOfferDocument, options);\n      }\nexport type CreateNotesOfferMutationHookResult = ReturnType<typeof useCreateNotesOfferMutation>;\nexport type CreateNotesOfferMutationResult = Apollo.MutationResult<CreateNotesOfferMutation>;\nexport type CreateNotesOfferMutationOptions = Apollo.BaseMutationOptions<CreateNotesOfferMutation, CreateNotesOfferMutationVariables>;\nexport const EditNotesOfferDocument: TypedDocumentNode<EditNotesOfferMutation, EditNotesOfferMutationVariables> = gql`\n  mutation editNotesOffer($offer: NotesRoundOfferCakeType!, $noteType: String!, $principal: CakeDecimal!, $discountRate: CakeDecimal, $valuationCap: CakeDecimal, $interest: Interest, $maturityDate: Date, $round: String, $sharetype: SharetypeCakeType) {\n  editNotesOffer(\n    offer: $offer\n    noteType: $noteType\n    principal: $principal\n    discountRate: $discountRate\n    valuationCap: $valuationCap\n    interest: $interest\n    maturityDate: $maturityDate\n    round: $round\n    sharetype: $sharetype\n  )\n}\n    `;\nexport type EditNotesOfferMutationFn = Apollo.MutationFunction<EditNotesOfferMutation, EditNotesOfferMutationVariables>;\n\n/**\n * __useEditNotesOfferMutation__\n *\n * To run a mutation, you first call `useEditNotesOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditNotesOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editNotesOfferMutation, { data, loading, error }] = useEditNotesOfferMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      noteType: // value for 'noteType'\n *      principal: // value for 'principal'\n *      discountRate: // value for 'discountRate'\n *      valuationCap: // value for 'valuationCap'\n *      interest: // value for 'interest'\n *      maturityDate: // value for 'maturityDate'\n *      round: // value for 'round'\n *      sharetype: // value for 'sharetype'\n *   },\n * });\n */\nexport function useEditNotesOfferMutation(baseOptions?: Apollo.MutationHookOptions<EditNotesOfferMutation, EditNotesOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditNotesOfferMutation, EditNotesOfferMutationVariables>(EditNotesOfferDocument, options);\n      }\nexport type EditNotesOfferMutationHookResult = ReturnType<typeof useEditNotesOfferMutation>;\nexport type EditNotesOfferMutationResult = Apollo.MutationResult<EditNotesOfferMutation>;\nexport type EditNotesOfferMutationOptions = Apollo.BaseMutationOptions<EditNotesOfferMutation, EditNotesOfferMutationVariables>;\nexport const CreateTemplateNoteDocument: TypedDocumentNode<CreateTemplateNoteMutation, CreateTemplateNoteMutationVariables> = gql`\n  mutation createTemplateNote($organisation: OrganisationCakeType!, $templateType: String!, $name: CleanString, $baseTemplate: DocumentCakeType) {\n  createTemplateNote(\n    organisation: $organisation\n    templateType: $templateType\n    name: $name\n    baseTemplate: $baseTemplate\n  )\n}\n    `;\nexport type CreateTemplateNoteMutationFn = Apollo.MutationFunction<CreateTemplateNoteMutation, CreateTemplateNoteMutationVariables>;\n\n/**\n * __useCreateTemplateNoteMutation__\n *\n * To run a mutation, you first call `useCreateTemplateNoteMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateTemplateNoteMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createTemplateNoteMutation, { data, loading, error }] = useCreateTemplateNoteMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      templateType: // value for 'templateType'\n *      name: // value for 'name'\n *      baseTemplate: // value for 'baseTemplate'\n *   },\n * });\n */\nexport function useCreateTemplateNoteMutation(baseOptions?: Apollo.MutationHookOptions<CreateTemplateNoteMutation, CreateTemplateNoteMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateTemplateNoteMutation, CreateTemplateNoteMutationVariables>(CreateTemplateNoteDocument, options);\n      }\nexport type CreateTemplateNoteMutationHookResult = ReturnType<typeof useCreateTemplateNoteMutation>;\nexport type CreateTemplateNoteMutationResult = Apollo.MutationResult<CreateTemplateNoteMutation>;\nexport type CreateTemplateNoteMutationOptions = Apollo.BaseMutationOptions<CreateTemplateNoteMutation, CreateTemplateNoteMutationVariables>;\nexport const SetNotesRoundTemplateDocument: TypedDocumentNode<SetNotesRoundTemplateMutation, SetNotesRoundTemplateMutationVariables> = gql`\n  mutation setNotesRoundTemplate($round: NotesRoundCakeType!, $contractTemplate: DocumentCakeType) {\n  setNotesRoundTemplate(round: $round, contractTemplate: $contractTemplate)\n}\n    `;\nexport type SetNotesRoundTemplateMutationFn = Apollo.MutationFunction<SetNotesRoundTemplateMutation, SetNotesRoundTemplateMutationVariables>;\n\n/**\n * __useSetNotesRoundTemplateMutation__\n *\n * To run a mutation, you first call `useSetNotesRoundTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSetNotesRoundTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [setNotesRoundTemplateMutation, { data, loading, error }] = useSetNotesRoundTemplateMutation({\n *   variables: {\n *      round: // value for 'round'\n *      contractTemplate: // value for 'contractTemplate'\n *   },\n * });\n */\nexport function useSetNotesRoundTemplateMutation(baseOptions?: Apollo.MutationHookOptions<SetNotesRoundTemplateMutation, SetNotesRoundTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SetNotesRoundTemplateMutation, SetNotesRoundTemplateMutationVariables>(SetNotesRoundTemplateDocument, options);\n      }\nexport type SetNotesRoundTemplateMutationHookResult = ReturnType<typeof useSetNotesRoundTemplateMutation>;\nexport type SetNotesRoundTemplateMutationResult = Apollo.MutationResult<SetNotesRoundTemplateMutation>;\nexport type SetNotesRoundTemplateMutationOptions = Apollo.BaseMutationOptions<SetNotesRoundTemplateMutation, SetNotesRoundTemplateMutationVariables>;\nexport const SetNotesOfferTemplateDocument: TypedDocumentNode<SetNotesOfferTemplateMutation, SetNotesOfferTemplateMutationVariables> = gql`\n  mutation setNotesOfferTemplate($offer: NotesRoundOfferCakeType!, $contractTemplate: DocumentCakeType) {\n  setNotesOfferTemplate(offer: $offer, contractTemplate: $contractTemplate)\n}\n    `;\nexport type SetNotesOfferTemplateMutationFn = Apollo.MutationFunction<SetNotesOfferTemplateMutation, SetNotesOfferTemplateMutationVariables>;\n\n/**\n * __useSetNotesOfferTemplateMutation__\n *\n * To run a mutation, you first call `useSetNotesOfferTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSetNotesOfferTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [setNotesOfferTemplateMutation, { data, loading, error }] = useSetNotesOfferTemplateMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      contractTemplate: // value for 'contractTemplate'\n *   },\n * });\n */\nexport function useSetNotesOfferTemplateMutation(baseOptions?: Apollo.MutationHookOptions<SetNotesOfferTemplateMutation, SetNotesOfferTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SetNotesOfferTemplateMutation, SetNotesOfferTemplateMutationVariables>(SetNotesOfferTemplateDocument, options);\n      }\nexport type SetNotesOfferTemplateMutationHookResult = ReturnType<typeof useSetNotesOfferTemplateMutation>;\nexport type SetNotesOfferTemplateMutationResult = Apollo.MutationResult<SetNotesOfferTemplateMutation>;\nexport type SetNotesOfferTemplateMutationOptions = Apollo.BaseMutationOptions<SetNotesOfferTemplateMutation, SetNotesOfferTemplateMutationVariables>;\nexport const CreateNotesOfferTemplateDocument: TypedDocumentNode<CreateNotesOfferTemplateMutation, CreateNotesOfferTemplateMutationVariables> = gql`\n  mutation createNotesOfferTemplate($offer: NotesRoundOfferCakeType!) {\n  createNotesOfferTemplate(offer: $offer)\n}\n    `;\nexport type CreateNotesOfferTemplateMutationFn = Apollo.MutationFunction<CreateNotesOfferTemplateMutation, CreateNotesOfferTemplateMutationVariables>;\n\n/**\n * __useCreateNotesOfferTemplateMutation__\n *\n * To run a mutation, you first call `useCreateNotesOfferTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateNotesOfferTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createNotesOfferTemplateMutation, { data, loading, error }] = useCreateNotesOfferTemplateMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *   },\n * });\n */\nexport function useCreateNotesOfferTemplateMutation(baseOptions?: Apollo.MutationHookOptions<CreateNotesOfferTemplateMutation, CreateNotesOfferTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateNotesOfferTemplateMutation, CreateNotesOfferTemplateMutationVariables>(CreateNotesOfferTemplateDocument, options);\n      }\nexport type CreateNotesOfferTemplateMutationHookResult = ReturnType<typeof useCreateNotesOfferTemplateMutation>;\nexport type CreateNotesOfferTemplateMutationResult = Apollo.MutationResult<CreateNotesOfferTemplateMutation>;\nexport type CreateNotesOfferTemplateMutationOptions = Apollo.BaseMutationOptions<CreateNotesOfferTemplateMutation, CreateNotesOfferTemplateMutationVariables>;\nexport const GetMasterTemplateViewLinkDocument: TypedDocumentNode<GetMasterTemplateViewLinkQuery, GetMasterTemplateViewLinkQueryVariables> = gql`\n  query getMasterTemplateViewLink($organisation: OrganisationCakeType!, $contractType: CleanString!) {\n  templateViewLink(organisation: $organisation, contractType: $contractType)\n}\n    `;\n\n/**\n * __useGetMasterTemplateViewLinkQuery__\n *\n * To run a query within a React component, call `useGetMasterTemplateViewLinkQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetMasterTemplateViewLinkQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetMasterTemplateViewLinkQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      contractType: // value for 'contractType'\n *   },\n * });\n */\nexport function useGetMasterTemplateViewLinkQuery(baseOptions: Apollo.QueryHookOptions<GetMasterTemplateViewLinkQuery, GetMasterTemplateViewLinkQueryVariables> & ({ variables: GetMasterTemplateViewLinkQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetMasterTemplateViewLinkQuery, GetMasterTemplateViewLinkQueryVariables>(GetMasterTemplateViewLinkDocument, options);\n      }\nexport function useGetMasterTemplateViewLinkLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetMasterTemplateViewLinkQuery, GetMasterTemplateViewLinkQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetMasterTemplateViewLinkQuery, GetMasterTemplateViewLinkQueryVariables>(GetMasterTemplateViewLinkDocument, options);\n        }\nexport function useGetMasterTemplateViewLinkSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetMasterTemplateViewLinkQuery, GetMasterTemplateViewLinkQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetMasterTemplateViewLinkQuery, GetMasterTemplateViewLinkQueryVariables>(GetMasterTemplateViewLinkDocument, options);\n        }\nexport type GetMasterTemplateViewLinkQueryHookResult = ReturnType<typeof useGetMasterTemplateViewLinkQuery>;\nexport type GetMasterTemplateViewLinkLazyQueryHookResult = ReturnType<typeof useGetMasterTemplateViewLinkLazyQuery>;\nexport type GetMasterTemplateViewLinkSuspenseQueryHookResult = ReturnType<typeof useGetMasterTemplateViewLinkSuspenseQuery>;\nexport type GetMasterTemplateViewLinkQueryResult = Apollo.QueryResult<GetMasterTemplateViewLinkQuery, GetMasterTemplateViewLinkQueryVariables>;\nexport function refetchGetMasterTemplateViewLinkQuery(variables: GetMasterTemplateViewLinkQueryVariables) {\n      return { query: GetMasterTemplateViewLinkDocument, variables: variables };\n    }\nexport const GetNoteOfferToConvertDocument: TypedDocumentNode<GetNoteOfferToConvertQuery, GetNoteOfferToConvertQueryVariables> = gql`\n  query getNoteOfferToConvert($organisationId: UUID!, $notesOffer: NotesRoundOfferCakeType!) {\n  notesOffer(notesOffer: $notesOffer) {\n    id\n    noteType\n    status\n    principal\n    discountRate\n    valuationCap\n    maturityDate\n    interestRate\n    shareholder {\n      id\n      displayName\n    }\n    notesRound {\n      id\n      name\n    }\n    note {\n      issueDate\n    }\n  }\n  sharetypes(organisationId: $organisationId) {\n    id\n    name\n  }\n  organisation(organisationId: $organisationId) {\n    valuationAt {\n      valuation\n    }\n    fullyDilutedShares\n  }\n}\n    `;\n\n/**\n * __useGetNoteOfferToConvertQuery__\n *\n * To run a query within a React component, call `useGetNoteOfferToConvertQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetNoteOfferToConvertQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetNoteOfferToConvertQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      notesOffer: // value for 'notesOffer'\n *   },\n * });\n */\nexport function useGetNoteOfferToConvertQuery(baseOptions: Apollo.QueryHookOptions<GetNoteOfferToConvertQuery, GetNoteOfferToConvertQueryVariables> & ({ variables: GetNoteOfferToConvertQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetNoteOfferToConvertQuery, GetNoteOfferToConvertQueryVariables>(GetNoteOfferToConvertDocument, options);\n      }\nexport function useGetNoteOfferToConvertLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNoteOfferToConvertQuery, GetNoteOfferToConvertQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetNoteOfferToConvertQuery, GetNoteOfferToConvertQueryVariables>(GetNoteOfferToConvertDocument, options);\n        }\nexport function useGetNoteOfferToConvertSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetNoteOfferToConvertQuery, GetNoteOfferToConvertQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetNoteOfferToConvertQuery, GetNoteOfferToConvertQueryVariables>(GetNoteOfferToConvertDocument, options);\n        }\nexport type GetNoteOfferToConvertQueryHookResult = ReturnType<typeof useGetNoteOfferToConvertQuery>;\nexport type GetNoteOfferToConvertLazyQueryHookResult = ReturnType<typeof useGetNoteOfferToConvertLazyQuery>;\nexport type GetNoteOfferToConvertSuspenseQueryHookResult = ReturnType<typeof useGetNoteOfferToConvertSuspenseQuery>;\nexport type GetNoteOfferToConvertQueryResult = Apollo.QueryResult<GetNoteOfferToConvertQuery, GetNoteOfferToConvertQueryVariables>;\nexport function refetchGetNoteOfferToConvertQuery(variables: GetNoteOfferToConvertQueryVariables) {\n      return { query: GetNoteOfferToConvertDocument, variables: variables };\n    }\nexport const GetNoteOfferToInviteDocument: TypedDocumentNode<GetNoteOfferToInviteQuery, GetNoteOfferToInviteQueryVariables> = gql`\n  query getNoteOfferToInvite($notesOffer: NotesRoundOfferCakeType!) {\n  notesOffer(notesOffer: $notesOffer) {\n    id\n    notesRound {\n      id\n      name\n      payment {\n        ... on AuPaymentDetailsType {\n          accountName\n          accountNumber\n          bsb\n          reference\n          isTrustAccount\n        }\n        ... on SgPaymentDetailsType {\n          accountName\n          accountNumber\n          swiftCode\n          bankCode\n          branchCode\n        }\n        ... on FallbackPaymentDetailsType {\n          details\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetNoteOfferToInviteQuery__\n *\n * To run a query within a React component, call `useGetNoteOfferToInviteQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetNoteOfferToInviteQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetNoteOfferToInviteQuery({\n *   variables: {\n *      notesOffer: // value for 'notesOffer'\n *   },\n * });\n */\nexport function useGetNoteOfferToInviteQuery(baseOptions: Apollo.QueryHookOptions<GetNoteOfferToInviteQuery, GetNoteOfferToInviteQueryVariables> & ({ variables: GetNoteOfferToInviteQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetNoteOfferToInviteQuery, GetNoteOfferToInviteQueryVariables>(GetNoteOfferToInviteDocument, options);\n      }\nexport function useGetNoteOfferToInviteLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNoteOfferToInviteQuery, GetNoteOfferToInviteQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetNoteOfferToInviteQuery, GetNoteOfferToInviteQueryVariables>(GetNoteOfferToInviteDocument, options);\n        }\nexport function useGetNoteOfferToInviteSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetNoteOfferToInviteQuery, GetNoteOfferToInviteQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetNoteOfferToInviteQuery, GetNoteOfferToInviteQueryVariables>(GetNoteOfferToInviteDocument, options);\n        }\nexport type GetNoteOfferToInviteQueryHookResult = ReturnType<typeof useGetNoteOfferToInviteQuery>;\nexport type GetNoteOfferToInviteLazyQueryHookResult = ReturnType<typeof useGetNoteOfferToInviteLazyQuery>;\nexport type GetNoteOfferToInviteSuspenseQueryHookResult = ReturnType<typeof useGetNoteOfferToInviteSuspenseQuery>;\nexport type GetNoteOfferToInviteQueryResult = Apollo.QueryResult<GetNoteOfferToInviteQuery, GetNoteOfferToInviteQueryVariables>;\nexport function refetchGetNoteOfferToInviteQuery(variables: GetNoteOfferToInviteQueryVariables) {\n      return { query: GetNoteOfferToInviteDocument, variables: variables };\n    }\nexport const GetNoteOfferToEditDocument: TypedDocumentNode<GetNoteOfferToEditQuery, GetNoteOfferToEditQueryVariables> = gql`\n  query getNoteOfferToEdit($notesOffer: NotesRoundOfferCakeType!) {\n  notesOffer(notesOffer: $notesOffer) {\n    id\n    noteType\n    status\n    principal\n    discountRate\n    valuationCap\n    maturityDate\n    interestRate\n    shareType {\n      id\n    }\n    shareholder {\n      id\n      displayName\n      investorData {\n        email\n      }\n    }\n    notesRound {\n      id\n      name\n    }\n  }\n}\n    `;\n\n/**\n * __useGetNoteOfferToEditQuery__\n *\n * To run a query within a React component, call `useGetNoteOfferToEditQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetNoteOfferToEditQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetNoteOfferToEditQuery({\n *   variables: {\n *      notesOffer: // value for 'notesOffer'\n *   },\n * });\n */\nexport function useGetNoteOfferToEditQuery(baseOptions: Apollo.QueryHookOptions<GetNoteOfferToEditQuery, GetNoteOfferToEditQueryVariables> & ({ variables: GetNoteOfferToEditQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetNoteOfferToEditQuery, GetNoteOfferToEditQueryVariables>(GetNoteOfferToEditDocument, options);\n      }\nexport function useGetNoteOfferToEditLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNoteOfferToEditQuery, GetNoteOfferToEditQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetNoteOfferToEditQuery, GetNoteOfferToEditQueryVariables>(GetNoteOfferToEditDocument, options);\n        }\nexport function useGetNoteOfferToEditSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetNoteOfferToEditQuery, GetNoteOfferToEditQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetNoteOfferToEditQuery, GetNoteOfferToEditQueryVariables>(GetNoteOfferToEditDocument, options);\n        }\nexport type GetNoteOfferToEditQueryHookResult = ReturnType<typeof useGetNoteOfferToEditQuery>;\nexport type GetNoteOfferToEditLazyQueryHookResult = ReturnType<typeof useGetNoteOfferToEditLazyQuery>;\nexport type GetNoteOfferToEditSuspenseQueryHookResult = ReturnType<typeof useGetNoteOfferToEditSuspenseQuery>;\nexport type GetNoteOfferToEditQueryResult = Apollo.QueryResult<GetNoteOfferToEditQuery, GetNoteOfferToEditQueryVariables>;\nexport function refetchGetNoteOfferToEditQuery(variables: GetNoteOfferToEditQueryVariables) {\n      return { query: GetNoteOfferToEditDocument, variables: variables };\n    }\nexport const CreateNotesRoundDocument: TypedDocumentNode<CreateNotesRoundMutation, CreateNotesRoundMutationVariables> = gql`\n  mutation createNotesRound($organisation: OrganisationCakeType!, $name: CleanString!, $noteType: String!, $roundInvestmentGoal: CakeDecimal!, $capitalRaisingEventAmount: CakeDecimal, $discountRate: CakeDecimal, $valuationCap: CakeDecimal, $interest: Interest, $maturityDate: Date, $endDate: Date, $payment: JSONString) {\n  createNotesRound(\n    organisation: $organisation\n    name: $name\n    noteType: $noteType\n    roundInvestmentGoal: $roundInvestmentGoal\n    capitalRaisingEventAmount: $capitalRaisingEventAmount\n    discountRate: $discountRate\n    valuationCap: $valuationCap\n    interest: $interest\n    endDate: $endDate\n    maturityDate: $maturityDate\n    payment: $payment\n  ) {\n    notesRound {\n      id\n      name\n    }\n  }\n}\n    `;\nexport type CreateNotesRoundMutationFn = Apollo.MutationFunction<CreateNotesRoundMutation, CreateNotesRoundMutationVariables>;\n\n/**\n * __useCreateNotesRoundMutation__\n *\n * To run a mutation, you first call `useCreateNotesRoundMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateNotesRoundMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createNotesRoundMutation, { data, loading, error }] = useCreateNotesRoundMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      name: // value for 'name'\n *      noteType: // value for 'noteType'\n *      roundInvestmentGoal: // value for 'roundInvestmentGoal'\n *      capitalRaisingEventAmount: // value for 'capitalRaisingEventAmount'\n *      discountRate: // value for 'discountRate'\n *      valuationCap: // value for 'valuationCap'\n *      interest: // value for 'interest'\n *      maturityDate: // value for 'maturityDate'\n *      endDate: // value for 'endDate'\n *      payment: // value for 'payment'\n *   },\n * });\n */\nexport function useCreateNotesRoundMutation(baseOptions?: Apollo.MutationHookOptions<CreateNotesRoundMutation, CreateNotesRoundMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateNotesRoundMutation, CreateNotesRoundMutationVariables>(CreateNotesRoundDocument, options);\n      }\nexport type CreateNotesRoundMutationHookResult = ReturnType<typeof useCreateNotesRoundMutation>;\nexport type CreateNotesRoundMutationResult = Apollo.MutationResult<CreateNotesRoundMutation>;\nexport type CreateNotesRoundMutationOptions = Apollo.BaseMutationOptions<CreateNotesRoundMutation, CreateNotesRoundMutationVariables>;\nexport const EditNotesRoundDocument: TypedDocumentNode<EditNotesRoundMutation, EditNotesRoundMutationVariables> = gql`\n  mutation editNotesRound($round: NotesRoundCakeType!, $name: CleanString, $endDate: Date, $roundInvestmentGoal: CakeDecimal, $valuationCap: CakeDecimal, $discountRate: CakeDecimal, $capitalRaisingEventAmount: CakeDecimal, $interest: Interest, $maturityDate: Date) {\n  editNotesRound(\n    round: $round\n    name: $name\n    endDate: $endDate\n    roundInvestmentGoal: $roundInvestmentGoal\n    valuationCap: $valuationCap\n    discountRate: $discountRate\n    capitalRaisingEventAmount: $capitalRaisingEventAmount\n    interest: $interest\n    maturityDate: $maturityDate\n  ) {\n    ok\n  }\n}\n    `;\nexport type EditNotesRoundMutationFn = Apollo.MutationFunction<EditNotesRoundMutation, EditNotesRoundMutationVariables>;\n\n/**\n * __useEditNotesRoundMutation__\n *\n * To run a mutation, you first call `useEditNotesRoundMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditNotesRoundMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editNotesRoundMutation, { data, loading, error }] = useEditNotesRoundMutation({\n *   variables: {\n *      round: // value for 'round'\n *      name: // value for 'name'\n *      endDate: // value for 'endDate'\n *      roundInvestmentGoal: // value for 'roundInvestmentGoal'\n *      valuationCap: // value for 'valuationCap'\n *      discountRate: // value for 'discountRate'\n *      capitalRaisingEventAmount: // value for 'capitalRaisingEventAmount'\n *      interest: // value for 'interest'\n *      maturityDate: // value for 'maturityDate'\n *   },\n * });\n */\nexport function useEditNotesRoundMutation(baseOptions?: Apollo.MutationHookOptions<EditNotesRoundMutation, EditNotesRoundMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditNotesRoundMutation, EditNotesRoundMutationVariables>(EditNotesRoundDocument, options);\n      }\nexport type EditNotesRoundMutationHookResult = ReturnType<typeof useEditNotesRoundMutation>;\nexport type EditNotesRoundMutationResult = Apollo.MutationResult<EditNotesRoundMutation>;\nexport type EditNotesRoundMutationOptions = Apollo.BaseMutationOptions<EditNotesRoundMutation, EditNotesRoundMutationVariables>;\nexport const UpdateNotesRoundBankDetailsAuDocument: TypedDocumentNode<UpdateNotesRoundBankDetailsAuMutation, UpdateNotesRoundBankDetailsAuMutationVariables> = gql`\n  mutation updateNotesRoundBankDetailsAu($round: NotesRoundCakeType!, $accountName: String, $paymentAccount: String, $paymentBsb: String, $paymentReference: String, $isTrustAccount: Boolean) {\n  updateNotesRoundBankDetailsAu(\n    round: $round\n    accountName: $accountName\n    paymentAccount: $paymentAccount\n    paymentBsb: $paymentBsb\n    paymentReference: $paymentReference\n    isTrustAccount: $isTrustAccount\n  ) {\n    ok\n  }\n}\n    `;\nexport type UpdateNotesRoundBankDetailsAuMutationFn = Apollo.MutationFunction<UpdateNotesRoundBankDetailsAuMutation, UpdateNotesRoundBankDetailsAuMutationVariables>;\n\n/**\n * __useUpdateNotesRoundBankDetailsAuMutation__\n *\n * To run a mutation, you first call `useUpdateNotesRoundBankDetailsAuMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateNotesRoundBankDetailsAuMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateNotesRoundBankDetailsAuMutation, { data, loading, error }] = useUpdateNotesRoundBankDetailsAuMutation({\n *   variables: {\n *      round: // value for 'round'\n *      accountName: // value for 'accountName'\n *      paymentAccount: // value for 'paymentAccount'\n *      paymentBsb: // value for 'paymentBsb'\n *      paymentReference: // value for 'paymentReference'\n *      isTrustAccount: // value for 'isTrustAccount'\n *   },\n * });\n */\nexport function useUpdateNotesRoundBankDetailsAuMutation(baseOptions?: Apollo.MutationHookOptions<UpdateNotesRoundBankDetailsAuMutation, UpdateNotesRoundBankDetailsAuMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateNotesRoundBankDetailsAuMutation, UpdateNotesRoundBankDetailsAuMutationVariables>(UpdateNotesRoundBankDetailsAuDocument, options);\n      }\nexport type UpdateNotesRoundBankDetailsAuMutationHookResult = ReturnType<typeof useUpdateNotesRoundBankDetailsAuMutation>;\nexport type UpdateNotesRoundBankDetailsAuMutationResult = Apollo.MutationResult<UpdateNotesRoundBankDetailsAuMutation>;\nexport type UpdateNotesRoundBankDetailsAuMutationOptions = Apollo.BaseMutationOptions<UpdateNotesRoundBankDetailsAuMutation, UpdateNotesRoundBankDetailsAuMutationVariables>;\nexport const UpdateNotesRoundBankDetailsSgDocument: TypedDocumentNode<UpdateNotesRoundBankDetailsSgMutation, UpdateNotesRoundBankDetailsSgMutationVariables> = gql`\n  mutation updateNotesRoundBankDetailsSg($round: NotesRoundCakeType!, $accountName: String, $accountNumber: String, $swiftCode: String, $bankCode: String, $branchCode: String) {\n  updateNotesRoundBankDetailsSg(\n    round: $round\n    accountName: $accountName\n    accountNumber: $accountNumber\n    swiftCode: $swiftCode\n    bankCode: $bankCode\n    branchCode: $branchCode\n  ) {\n    ok\n  }\n}\n    `;\nexport type UpdateNotesRoundBankDetailsSgMutationFn = Apollo.MutationFunction<UpdateNotesRoundBankDetailsSgMutation, UpdateNotesRoundBankDetailsSgMutationVariables>;\n\n/**\n * __useUpdateNotesRoundBankDetailsSgMutation__\n *\n * To run a mutation, you first call `useUpdateNotesRoundBankDetailsSgMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateNotesRoundBankDetailsSgMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateNotesRoundBankDetailsSgMutation, { data, loading, error }] = useUpdateNotesRoundBankDetailsSgMutation({\n *   variables: {\n *      round: // value for 'round'\n *      accountName: // value for 'accountName'\n *      accountNumber: // value for 'accountNumber'\n *      swiftCode: // value for 'swiftCode'\n *      bankCode: // value for 'bankCode'\n *      branchCode: // value for 'branchCode'\n *   },\n * });\n */\nexport function useUpdateNotesRoundBankDetailsSgMutation(baseOptions?: Apollo.MutationHookOptions<UpdateNotesRoundBankDetailsSgMutation, UpdateNotesRoundBankDetailsSgMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateNotesRoundBankDetailsSgMutation, UpdateNotesRoundBankDetailsSgMutationVariables>(UpdateNotesRoundBankDetailsSgDocument, options);\n      }\nexport type UpdateNotesRoundBankDetailsSgMutationHookResult = ReturnType<typeof useUpdateNotesRoundBankDetailsSgMutation>;\nexport type UpdateNotesRoundBankDetailsSgMutationResult = Apollo.MutationResult<UpdateNotesRoundBankDetailsSgMutation>;\nexport type UpdateNotesRoundBankDetailsSgMutationOptions = Apollo.BaseMutationOptions<UpdateNotesRoundBankDetailsSgMutation, UpdateNotesRoundBankDetailsSgMutationVariables>;\nexport const UpdateNotesRoundBankDetailsFallbackDocument: TypedDocumentNode<UpdateNotesRoundBankDetailsFallbackMutation, UpdateNotesRoundBankDetailsFallbackMutationVariables> = gql`\n  mutation updateNotesRoundBankDetailsFallback($round: NotesRoundCakeType!, $details: String) {\n  updateNotesRoundBankDetailsFallback(round: $round, details: $details) {\n    ok\n  }\n}\n    `;\nexport type UpdateNotesRoundBankDetailsFallbackMutationFn = Apollo.MutationFunction<UpdateNotesRoundBankDetailsFallbackMutation, UpdateNotesRoundBankDetailsFallbackMutationVariables>;\n\n/**\n * __useUpdateNotesRoundBankDetailsFallbackMutation__\n *\n * To run a mutation, you first call `useUpdateNotesRoundBankDetailsFallbackMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateNotesRoundBankDetailsFallbackMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateNotesRoundBankDetailsFallbackMutation, { data, loading, error }] = useUpdateNotesRoundBankDetailsFallbackMutation({\n *   variables: {\n *      round: // value for 'round'\n *      details: // value for 'details'\n *   },\n * });\n */\nexport function useUpdateNotesRoundBankDetailsFallbackMutation(baseOptions?: Apollo.MutationHookOptions<UpdateNotesRoundBankDetailsFallbackMutation, UpdateNotesRoundBankDetailsFallbackMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateNotesRoundBankDetailsFallbackMutation, UpdateNotesRoundBankDetailsFallbackMutationVariables>(UpdateNotesRoundBankDetailsFallbackDocument, options);\n      }\nexport type UpdateNotesRoundBankDetailsFallbackMutationHookResult = ReturnType<typeof useUpdateNotesRoundBankDetailsFallbackMutation>;\nexport type UpdateNotesRoundBankDetailsFallbackMutationResult = Apollo.MutationResult<UpdateNotesRoundBankDetailsFallbackMutation>;\nexport type UpdateNotesRoundBankDetailsFallbackMutationOptions = Apollo.BaseMutationOptions<UpdateNotesRoundBankDetailsFallbackMutation, UpdateNotesRoundBankDetailsFallbackMutationVariables>;\nexport const DeleteNotesRoundDocument: TypedDocumentNode<DeleteNotesRoundMutation, DeleteNotesRoundMutationVariables> = gql`\n  mutation deleteNotesRound($round: NotesRoundCakeType!) {\n  deleteNotesRound(round: $round) {\n    ok\n  }\n}\n    `;\nexport type DeleteNotesRoundMutationFn = Apollo.MutationFunction<DeleteNotesRoundMutation, DeleteNotesRoundMutationVariables>;\n\n/**\n * __useDeleteNotesRoundMutation__\n *\n * To run a mutation, you first call `useDeleteNotesRoundMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteNotesRoundMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteNotesRoundMutation, { data, loading, error }] = useDeleteNotesRoundMutation({\n *   variables: {\n *      round: // value for 'round'\n *   },\n * });\n */\nexport function useDeleteNotesRoundMutation(baseOptions?: Apollo.MutationHookOptions<DeleteNotesRoundMutation, DeleteNotesRoundMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteNotesRoundMutation, DeleteNotesRoundMutationVariables>(DeleteNotesRoundDocument, options);\n      }\nexport type DeleteNotesRoundMutationHookResult = ReturnType<typeof useDeleteNotesRoundMutation>;\nexport type DeleteNotesRoundMutationResult = Apollo.MutationResult<DeleteNotesRoundMutation>;\nexport type DeleteNotesRoundMutationOptions = Apollo.BaseMutationOptions<DeleteNotesRoundMutation, DeleteNotesRoundMutationVariables>;\nexport const GetNotesRoundDocument: TypedDocumentNode<GetNotesRoundQuery, GetNotesRoundQueryVariables> = gql`\n  query getNotesRound($organisationId: UUID!, $organisation: OrganisationCakeType!, $roundId: UUID!) {\n  notesRounds(organisation: $organisation, filterRound: $roundId) {\n    id\n    name\n    roundInvestmentGoal\n    created\n    noteType\n    amountRaised\n    amountPaid\n    minInvestmentAmount\n    maxInvestmentAmount\n    endDate\n    capitalRaisingEventAmount\n    valuationCap\n    interestRate\n    discountRate\n    maturityDate\n    payment {\n      ... on AuPaymentDetailsType {\n        accountName\n        accountNumber\n        bsb\n        reference\n        isTrustAccount\n      }\n      ... on SgPaymentDetailsType {\n        accountName\n        accountNumber\n        swiftCode\n        bankCode\n        branchCode\n      }\n      ... on FallbackPaymentDetailsType {\n        details\n      }\n    }\n    contractTemplate {\n      id\n      name\n      status\n      contractType\n    }\n    shareType {\n      id\n      name\n    }\n    documents {\n      id\n      created\n      name\n      file\n      extension\n    }\n  }\n  officeholders(organisationId: $organisationId, filterSigners: true) {\n    id\n    name\n    email\n    avatar\n    roles {\n      role\n      name\n    }\n    signer\n  }\n}\n    `;\n\n/**\n * __useGetNotesRoundQuery__\n *\n * To run a query within a React component, call `useGetNotesRoundQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetNotesRoundQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetNotesRoundQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      organisation: // value for 'organisation'\n *      roundId: // value for 'roundId'\n *   },\n * });\n */\nexport function useGetNotesRoundQuery(baseOptions: Apollo.QueryHookOptions<GetNotesRoundQuery, GetNotesRoundQueryVariables> & ({ variables: GetNotesRoundQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetNotesRoundQuery, GetNotesRoundQueryVariables>(GetNotesRoundDocument, options);\n      }\nexport function useGetNotesRoundLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNotesRoundQuery, GetNotesRoundQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetNotesRoundQuery, GetNotesRoundQueryVariables>(GetNotesRoundDocument, options);\n        }\nexport function useGetNotesRoundSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetNotesRoundQuery, GetNotesRoundQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetNotesRoundQuery, GetNotesRoundQueryVariables>(GetNotesRoundDocument, options);\n        }\nexport type GetNotesRoundQueryHookResult = ReturnType<typeof useGetNotesRoundQuery>;\nexport type GetNotesRoundLazyQueryHookResult = ReturnType<typeof useGetNotesRoundLazyQuery>;\nexport type GetNotesRoundSuspenseQueryHookResult = ReturnType<typeof useGetNotesRoundSuspenseQuery>;\nexport type GetNotesRoundQueryResult = Apollo.QueryResult<GetNotesRoundQuery, GetNotesRoundQueryVariables>;\nexport function refetchGetNotesRoundQuery(variables: GetNotesRoundQueryVariables) {\n      return { query: GetNotesRoundDocument, variables: variables };\n    }\nexport const NotesRoundOffersDocument: TypedDocumentNode<NotesRoundOffersQuery, NotesRoundOffersQueryVariables> = gql`\n  query notesRoundOffers($round: NotesRoundCakeType!, $page: Int, $itemsPerPage: Int, $offer: UUID) {\n  notesRoundOffers(\n    round: $round\n    page: $page\n    itemsPerPage: $itemsPerPage\n    filterOffer: $offer\n  ) {\n    id\n    modified\n    status\n    principal\n    owing\n    shareholder {\n      id\n      displayName\n      secondaryName\n      avatar\n      inviteLink\n      computedType\n      investorData {\n        name\n        email\n        jointIndex\n        companyData {\n          signers {\n            name\n            email\n          }\n        }\n      }\n    }\n    contract {\n      id\n      name\n      contractType\n      signatures {\n        name\n        email\n        status\n        extra\n      }\n    }\n    notesRound {\n      id\n      noteType\n    }\n    requireWitness\n  }\n}\n    `;\n\n/**\n * __useNotesRoundOffersQuery__\n *\n * To run a query within a React component, call `useNotesRoundOffersQuery` and pass it any options that fit your needs.\n * When your component renders, `useNotesRoundOffersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useNotesRoundOffersQuery({\n *   variables: {\n *      round: // value for 'round'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      offer: // value for 'offer'\n *   },\n * });\n */\nexport function useNotesRoundOffersQuery(baseOptions: Apollo.QueryHookOptions<NotesRoundOffersQuery, NotesRoundOffersQueryVariables> & ({ variables: NotesRoundOffersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<NotesRoundOffersQuery, NotesRoundOffersQueryVariables>(NotesRoundOffersDocument, options);\n      }\nexport function useNotesRoundOffersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<NotesRoundOffersQuery, NotesRoundOffersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<NotesRoundOffersQuery, NotesRoundOffersQueryVariables>(NotesRoundOffersDocument, options);\n        }\nexport function useNotesRoundOffersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<NotesRoundOffersQuery, NotesRoundOffersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<NotesRoundOffersQuery, NotesRoundOffersQueryVariables>(NotesRoundOffersDocument, options);\n        }\nexport type NotesRoundOffersQueryHookResult = ReturnType<typeof useNotesRoundOffersQuery>;\nexport type NotesRoundOffersLazyQueryHookResult = ReturnType<typeof useNotesRoundOffersLazyQuery>;\nexport type NotesRoundOffersSuspenseQueryHookResult = ReturnType<typeof useNotesRoundOffersSuspenseQuery>;\nexport type NotesRoundOffersQueryResult = Apollo.QueryResult<NotesRoundOffersQuery, NotesRoundOffersQueryVariables>;\nexport function refetchNotesRoundOffersQuery(variables: NotesRoundOffersQueryVariables) {\n      return { query: NotesRoundOffersDocument, variables: variables };\n    }\nexport const CreateNotesRoundTemplateDocument: TypedDocumentNode<CreateNotesRoundTemplateMutation, CreateNotesRoundTemplateMutationVariables> = gql`\n  mutation createNotesRoundTemplate($round: NotesRoundCakeType!, $name: CleanString!, $baseTemplate: DocumentCakeType) {\n  createNotesRoundTemplate(\n    round: $round\n    name: $name\n    baseTemplate: $baseTemplate\n  ) {\n    ok\n  }\n}\n    `;\nexport type CreateNotesRoundTemplateMutationFn = Apollo.MutationFunction<CreateNotesRoundTemplateMutation, CreateNotesRoundTemplateMutationVariables>;\n\n/**\n * __useCreateNotesRoundTemplateMutation__\n *\n * To run a mutation, you first call `useCreateNotesRoundTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateNotesRoundTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createNotesRoundTemplateMutation, { data, loading, error }] = useCreateNotesRoundTemplateMutation({\n *   variables: {\n *      round: // value for 'round'\n *      name: // value for 'name'\n *      baseTemplate: // value for 'baseTemplate'\n *   },\n * });\n */\nexport function useCreateNotesRoundTemplateMutation(baseOptions?: Apollo.MutationHookOptions<CreateNotesRoundTemplateMutation, CreateNotesRoundTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateNotesRoundTemplateMutation, CreateNotesRoundTemplateMutationVariables>(CreateNotesRoundTemplateDocument, options);\n      }\nexport type CreateNotesRoundTemplateMutationHookResult = ReturnType<typeof useCreateNotesRoundTemplateMutation>;\nexport type CreateNotesRoundTemplateMutationResult = Apollo.MutationResult<CreateNotesRoundTemplateMutation>;\nexport type CreateNotesRoundTemplateMutationOptions = Apollo.BaseMutationOptions<CreateNotesRoundTemplateMutation, CreateNotesRoundTemplateMutationVariables>;\nexport const DeleteNotesRoundTemplateDocument: TypedDocumentNode<DeleteNotesRoundTemplateMutation, DeleteNotesRoundTemplateMutationVariables> = gql`\n  mutation deleteNotesRoundTemplate($round: NotesRoundCakeType!) {\n  deleteNotesRoundTemplate(round: $round) {\n    ok\n  }\n}\n    `;\nexport type DeleteNotesRoundTemplateMutationFn = Apollo.MutationFunction<DeleteNotesRoundTemplateMutation, DeleteNotesRoundTemplateMutationVariables>;\n\n/**\n * __useDeleteNotesRoundTemplateMutation__\n *\n * To run a mutation, you first call `useDeleteNotesRoundTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteNotesRoundTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteNotesRoundTemplateMutation, { data, loading, error }] = useDeleteNotesRoundTemplateMutation({\n *   variables: {\n *      round: // value for 'round'\n *   },\n * });\n */\nexport function useDeleteNotesRoundTemplateMutation(baseOptions?: Apollo.MutationHookOptions<DeleteNotesRoundTemplateMutation, DeleteNotesRoundTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteNotesRoundTemplateMutation, DeleteNotesRoundTemplateMutationVariables>(DeleteNotesRoundTemplateDocument, options);\n      }\nexport type DeleteNotesRoundTemplateMutationHookResult = ReturnType<typeof useDeleteNotesRoundTemplateMutation>;\nexport type DeleteNotesRoundTemplateMutationResult = Apollo.MutationResult<DeleteNotesRoundTemplateMutation>;\nexport type DeleteNotesRoundTemplateMutationOptions = Apollo.BaseMutationOptions<DeleteNotesRoundTemplateMutation, DeleteNotesRoundTemplateMutationVariables>;\nexport const AddNotesRoundOfferDocument: TypedDocumentNode<AddNotesRoundOfferMutation, AddNotesRoundOfferMutationVariables> = gql`\n  mutation addNotesRoundOffer($round: NotesRoundCakeType!, $shareholder: ShareholderCakeType!, $principal: CakeDecimal!) {\n  createNotesRoundOffer(\n    round: $round\n    shareholder: $shareholder\n    principal: $principal\n  ) {\n    notesRoundOffer {\n      id\n    }\n  }\n}\n    `;\nexport type AddNotesRoundOfferMutationFn = Apollo.MutationFunction<AddNotesRoundOfferMutation, AddNotesRoundOfferMutationVariables>;\n\n/**\n * __useAddNotesRoundOfferMutation__\n *\n * To run a mutation, you first call `useAddNotesRoundOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddNotesRoundOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addNotesRoundOfferMutation, { data, loading, error }] = useAddNotesRoundOfferMutation({\n *   variables: {\n *      round: // value for 'round'\n *      shareholder: // value for 'shareholder'\n *      principal: // value for 'principal'\n *   },\n * });\n */\nexport function useAddNotesRoundOfferMutation(baseOptions?: Apollo.MutationHookOptions<AddNotesRoundOfferMutation, AddNotesRoundOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddNotesRoundOfferMutation, AddNotesRoundOfferMutationVariables>(AddNotesRoundOfferDocument, options);\n      }\nexport type AddNotesRoundOfferMutationHookResult = ReturnType<typeof useAddNotesRoundOfferMutation>;\nexport type AddNotesRoundOfferMutationResult = Apollo.MutationResult<AddNotesRoundOfferMutation>;\nexport type AddNotesRoundOfferMutationOptions = Apollo.BaseMutationOptions<AddNotesRoundOfferMutation, AddNotesRoundOfferMutationVariables>;\nexport const DeleteNotesRoundOfferDocument: TypedDocumentNode<DeleteNotesRoundOfferMutation, DeleteNotesRoundOfferMutationVariables> = gql`\n  mutation deleteNotesRoundOffer($offer: NotesRoundOfferCakeType!) {\n  deleteNotesRoundOffer(offer: $offer)\n}\n    `;\nexport type DeleteNotesRoundOfferMutationFn = Apollo.MutationFunction<DeleteNotesRoundOfferMutation, DeleteNotesRoundOfferMutationVariables>;\n\n/**\n * __useDeleteNotesRoundOfferMutation__\n *\n * To run a mutation, you first call `useDeleteNotesRoundOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteNotesRoundOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteNotesRoundOfferMutation, { data, loading, error }] = useDeleteNotesRoundOfferMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *   },\n * });\n */\nexport function useDeleteNotesRoundOfferMutation(baseOptions?: Apollo.MutationHookOptions<DeleteNotesRoundOfferMutation, DeleteNotesRoundOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteNotesRoundOfferMutation, DeleteNotesRoundOfferMutationVariables>(DeleteNotesRoundOfferDocument, options);\n      }\nexport type DeleteNotesRoundOfferMutationHookResult = ReturnType<typeof useDeleteNotesRoundOfferMutation>;\nexport type DeleteNotesRoundOfferMutationResult = Apollo.MutationResult<DeleteNotesRoundOfferMutation>;\nexport type DeleteNotesRoundOfferMutationOptions = Apollo.BaseMutationOptions<DeleteNotesRoundOfferMutation, DeleteNotesRoundOfferMutationVariables>;\nexport const ResetNotesRoundOfferDocument: TypedDocumentNode<ResetNotesRoundOfferMutation, ResetNotesRoundOfferMutationVariables> = gql`\n  mutation resetNotesRoundOffer($offer: NotesRoundOfferCakeType!, $keepContracts: Boolean!) {\n  resetNotesOffer(offer: $offer, keepContracts: $keepContracts)\n}\n    `;\nexport type ResetNotesRoundOfferMutationFn = Apollo.MutationFunction<ResetNotesRoundOfferMutation, ResetNotesRoundOfferMutationVariables>;\n\n/**\n * __useResetNotesRoundOfferMutation__\n *\n * To run a mutation, you first call `useResetNotesRoundOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useResetNotesRoundOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [resetNotesRoundOfferMutation, { data, loading, error }] = useResetNotesRoundOfferMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      keepContracts: // value for 'keepContracts'\n *   },\n * });\n */\nexport function useResetNotesRoundOfferMutation(baseOptions?: Apollo.MutationHookOptions<ResetNotesRoundOfferMutation, ResetNotesRoundOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ResetNotesRoundOfferMutation, ResetNotesRoundOfferMutationVariables>(ResetNotesRoundOfferDocument, options);\n      }\nexport type ResetNotesRoundOfferMutationHookResult = ReturnType<typeof useResetNotesRoundOfferMutation>;\nexport type ResetNotesRoundOfferMutationResult = Apollo.MutationResult<ResetNotesRoundOfferMutation>;\nexport type ResetNotesRoundOfferMutationOptions = Apollo.BaseMutationOptions<ResetNotesRoundOfferMutation, ResetNotesRoundOfferMutationVariables>;\nexport const UpdateNotesOfferPaymentStatusDocument: TypedDocumentNode<UpdateNotesOfferPaymentStatusMutation, UpdateNotesOfferPaymentStatusMutationVariables> = gql`\n  mutation updateNotesOfferPaymentStatus($offer: NotesRoundOfferCakeType!, $paid: CakeDecimal!, $issueDate: Date, $notify: Boolean) {\n  updateNotesOfferPaymentStatus(\n    offer: $offer\n    paid: $paid\n    issueDate: $issueDate\n    notify: $notify\n  ) {\n    ok\n  }\n}\n    `;\nexport type UpdateNotesOfferPaymentStatusMutationFn = Apollo.MutationFunction<UpdateNotesOfferPaymentStatusMutation, UpdateNotesOfferPaymentStatusMutationVariables>;\n\n/**\n * __useUpdateNotesOfferPaymentStatusMutation__\n *\n * To run a mutation, you first call `useUpdateNotesOfferPaymentStatusMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateNotesOfferPaymentStatusMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateNotesOfferPaymentStatusMutation, { data, loading, error }] = useUpdateNotesOfferPaymentStatusMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      paid: // value for 'paid'\n *      issueDate: // value for 'issueDate'\n *      notify: // value for 'notify'\n *   },\n * });\n */\nexport function useUpdateNotesOfferPaymentStatusMutation(baseOptions?: Apollo.MutationHookOptions<UpdateNotesOfferPaymentStatusMutation, UpdateNotesOfferPaymentStatusMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateNotesOfferPaymentStatusMutation, UpdateNotesOfferPaymentStatusMutationVariables>(UpdateNotesOfferPaymentStatusDocument, options);\n      }\nexport type UpdateNotesOfferPaymentStatusMutationHookResult = ReturnType<typeof useUpdateNotesOfferPaymentStatusMutation>;\nexport type UpdateNotesOfferPaymentStatusMutationResult = Apollo.MutationResult<UpdateNotesOfferPaymentStatusMutation>;\nexport type UpdateNotesOfferPaymentStatusMutationOptions = Apollo.BaseMutationOptions<UpdateNotesOfferPaymentStatusMutation, UpdateNotesOfferPaymentStatusMutationVariables>;\nexport const InviteNotesOfferDocument: TypedDocumentNode<InviteNotesOfferMutation, InviteNotesOfferMutationVariables> = gql`\n  mutation inviteNotesOffer($offer: NotesRoundOfferCakeType!, $sendInvitationEmail: Boolean!, $email: CleanString, $payment: JSONString) {\n  inviteNotesOffer(\n    offer: $offer\n    sendInvitationEmail: $sendInvitationEmail\n    email: $email\n    payment: $payment\n  ) {\n    ok\n  }\n}\n    `;\nexport type InviteNotesOfferMutationFn = Apollo.MutationFunction<InviteNotesOfferMutation, InviteNotesOfferMutationVariables>;\n\n/**\n * __useInviteNotesOfferMutation__\n *\n * To run a mutation, you first call `useInviteNotesOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useInviteNotesOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [inviteNotesOfferMutation, { data, loading, error }] = useInviteNotesOfferMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      sendInvitationEmail: // value for 'sendInvitationEmail'\n *      email: // value for 'email'\n *      payment: // value for 'payment'\n *   },\n * });\n */\nexport function useInviteNotesOfferMutation(baseOptions?: Apollo.MutationHookOptions<InviteNotesOfferMutation, InviteNotesOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<InviteNotesOfferMutation, InviteNotesOfferMutationVariables>(InviteNotesOfferDocument, options);\n      }\nexport type InviteNotesOfferMutationHookResult = ReturnType<typeof useInviteNotesOfferMutation>;\nexport type InviteNotesOfferMutationResult = Apollo.MutationResult<InviteNotesOfferMutation>;\nexport type InviteNotesOfferMutationOptions = Apollo.BaseMutationOptions<InviteNotesOfferMutation, InviteNotesOfferMutationVariables>;\nexport const SettleNotesOfferOfflineDocument: TypedDocumentNode<SettleNotesOfferOfflineMutation, SettleNotesOfferOfflineMutationVariables> = gql`\n  mutation settleNotesOfferOffline($offer: NotesRoundOfferCakeType!, $principal: CakeDecimal!, $contract: DocumentCakeType, $issueDate: Date, $notify: Boolean) {\n  settleNotesOfferOffline(\n    offer: $offer\n    principal: $principal\n    contract: $contract\n    issueDate: $issueDate\n    notify: $notify\n  ) {\n    ok\n  }\n}\n    `;\nexport type SettleNotesOfferOfflineMutationFn = Apollo.MutationFunction<SettleNotesOfferOfflineMutation, SettleNotesOfferOfflineMutationVariables>;\n\n/**\n * __useSettleNotesOfferOfflineMutation__\n *\n * To run a mutation, you first call `useSettleNotesOfferOfflineMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSettleNotesOfferOfflineMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [settleNotesOfferOfflineMutation, { data, loading, error }] = useSettleNotesOfferOfflineMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      principal: // value for 'principal'\n *      contract: // value for 'contract'\n *      issueDate: // value for 'issueDate'\n *      notify: // value for 'notify'\n *   },\n * });\n */\nexport function useSettleNotesOfferOfflineMutation(baseOptions?: Apollo.MutationHookOptions<SettleNotesOfferOfflineMutation, SettleNotesOfferOfflineMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SettleNotesOfferOfflineMutation, SettleNotesOfferOfflineMutationVariables>(SettleNotesOfferOfflineDocument, options);\n      }\nexport type SettleNotesOfferOfflineMutationHookResult = ReturnType<typeof useSettleNotesOfferOfflineMutation>;\nexport type SettleNotesOfferOfflineMutationResult = Apollo.MutationResult<SettleNotesOfferOfflineMutation>;\nexport type SettleNotesOfferOfflineMutationOptions = Apollo.BaseMutationOptions<SettleNotesOfferOfflineMutation, SettleNotesOfferOfflineMutationVariables>;\nexport const IssueNotesDocument: TypedDocumentNode<IssueNotesMutation, IssueNotesMutationVariables> = gql`\n  mutation issueNotes($shareholderId: UUID!, $type: String!, $totalPaid: CakeDecimal!, $valuationCap: CakeDecimal, $discountRate: CakeDecimal, $interest: Interest, $maturityDate: Date, $issueDate: Date, $comment: String) {\n  createNote(\n    shareholderId: $shareholderId\n    noteType: $type\n    principal: $totalPaid\n    valuationCap: $valuationCap\n    discountRate: $discountRate\n    interest: $interest\n    maturityDate: $maturityDate\n    issueDate: $issueDate\n    comment: $comment\n  ) {\n    note {\n      id\n    }\n  }\n}\n    `;\nexport type IssueNotesMutationFn = Apollo.MutationFunction<IssueNotesMutation, IssueNotesMutationVariables>;\n\n/**\n * __useIssueNotesMutation__\n *\n * To run a mutation, you first call `useIssueNotesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useIssueNotesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [issueNotesMutation, { data, loading, error }] = useIssueNotesMutation({\n *   variables: {\n *      shareholderId: // value for 'shareholderId'\n *      type: // value for 'type'\n *      totalPaid: // value for 'totalPaid'\n *      valuationCap: // value for 'valuationCap'\n *      discountRate: // value for 'discountRate'\n *      interest: // value for 'interest'\n *      maturityDate: // value for 'maturityDate'\n *      issueDate: // value for 'issueDate'\n *      comment: // value for 'comment'\n *   },\n * });\n */\nexport function useIssueNotesMutation(baseOptions?: Apollo.MutationHookOptions<IssueNotesMutation, IssueNotesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<IssueNotesMutation, IssueNotesMutationVariables>(IssueNotesDocument, options);\n      }\nexport type IssueNotesMutationHookResult = ReturnType<typeof useIssueNotesMutation>;\nexport type IssueNotesMutationResult = Apollo.MutationResult<IssueNotesMutation>;\nexport type IssueNotesMutationOptions = Apollo.BaseMutationOptions<IssueNotesMutation, IssueNotesMutationVariables>;\nexport const EditNoteDocument: TypedDocumentNode<EditNoteMutation, EditNoteMutationVariables> = gql`\n  mutation editNote($noteId: NoteCakeType!, $principal: CakeDecimal!, $valuationCap: CakeDecimal, $discountRate: CakeDecimal, $interest: Interest, $maturityDate: Date, $issueDate: Date, $comment: CleanString) {\n  editNote(\n    note: $noteId\n    principal: $principal\n    valuationCap: $valuationCap\n    discountRate: $discountRate\n    interest: $interest\n    maturityDate: $maturityDate\n    issueDate: $issueDate\n    comment: $comment\n  )\n}\n    `;\nexport type EditNoteMutationFn = Apollo.MutationFunction<EditNoteMutation, EditNoteMutationVariables>;\n\n/**\n * __useEditNoteMutation__\n *\n * To run a mutation, you first call `useEditNoteMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditNoteMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editNoteMutation, { data, loading, error }] = useEditNoteMutation({\n *   variables: {\n *      noteId: // value for 'noteId'\n *      principal: // value for 'principal'\n *      valuationCap: // value for 'valuationCap'\n *      discountRate: // value for 'discountRate'\n *      interest: // value for 'interest'\n *      maturityDate: // value for 'maturityDate'\n *      issueDate: // value for 'issueDate'\n *      comment: // value for 'comment'\n *   },\n * });\n */\nexport function useEditNoteMutation(baseOptions?: Apollo.MutationHookOptions<EditNoteMutation, EditNoteMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditNoteMutation, EditNoteMutationVariables>(EditNoteDocument, options);\n      }\nexport type EditNoteMutationHookResult = ReturnType<typeof useEditNoteMutation>;\nexport type EditNoteMutationResult = Apollo.MutationResult<EditNoteMutation>;\nexport type EditNoteMutationOptions = Apollo.BaseMutationOptions<EditNoteMutation, EditNoteMutationVariables>;\nexport const IssueOfferNoteDocument: TypedDocumentNode<IssueOfferNoteMutation, IssueOfferNoteMutationVariables> = gql`\n  mutation issueOfferNote($offer: NotesRoundOfferCakeType!, $issueDate: Date) {\n  issueOfferNote(offer: $offer, issueDate: $issueDate) {\n    note {\n      id\n    }\n  }\n}\n    `;\nexport type IssueOfferNoteMutationFn = Apollo.MutationFunction<IssueOfferNoteMutation, IssueOfferNoteMutationVariables>;\n\n/**\n * __useIssueOfferNoteMutation__\n *\n * To run a mutation, you first call `useIssueOfferNoteMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useIssueOfferNoteMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [issueOfferNoteMutation, { data, loading, error }] = useIssueOfferNoteMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      issueDate: // value for 'issueDate'\n *   },\n * });\n */\nexport function useIssueOfferNoteMutation(baseOptions?: Apollo.MutationHookOptions<IssueOfferNoteMutation, IssueOfferNoteMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<IssueOfferNoteMutation, IssueOfferNoteMutationVariables>(IssueOfferNoteDocument, options);\n      }\nexport type IssueOfferNoteMutationHookResult = ReturnType<typeof useIssueOfferNoteMutation>;\nexport type IssueOfferNoteMutationResult = Apollo.MutationResult<IssueOfferNoteMutation>;\nexport type IssueOfferNoteMutationOptions = Apollo.BaseMutationOptions<IssueOfferNoteMutation, IssueOfferNoteMutationVariables>;\nexport const ConvertNoteDocument: TypedDocumentNode<ConvertNoteMutation, ConvertNoteMutationVariables> = gql`\n  mutation convertNote($noteId: UUID!, $sharetypeId: UUID!, $pricePerShare: CakeDecimal!, $valuation: CakeDecimal, $date: Date, $dryRun: Boolean!) {\n  convertNote(\n    noteId: $noteId\n    sharetypeId: $sharetypeId\n    pricePerShare: $pricePerShare\n    valuation: $valuation\n    date: $date\n    dryRun: $dryRun\n  ) {\n    sharesIssued\n  }\n}\n    `;\nexport type ConvertNoteMutationFn = Apollo.MutationFunction<ConvertNoteMutation, ConvertNoteMutationVariables>;\n\n/**\n * __useConvertNoteMutation__\n *\n * To run a mutation, you first call `useConvertNoteMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useConvertNoteMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [convertNoteMutation, { data, loading, error }] = useConvertNoteMutation({\n *   variables: {\n *      noteId: // value for 'noteId'\n *      sharetypeId: // value for 'sharetypeId'\n *      pricePerShare: // value for 'pricePerShare'\n *      valuation: // value for 'valuation'\n *      date: // value for 'date'\n *      dryRun: // value for 'dryRun'\n *   },\n * });\n */\nexport function useConvertNoteMutation(baseOptions?: Apollo.MutationHookOptions<ConvertNoteMutation, ConvertNoteMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ConvertNoteMutation, ConvertNoteMutationVariables>(ConvertNoteDocument, options);\n      }\nexport type ConvertNoteMutationHookResult = ReturnType<typeof useConvertNoteMutation>;\nexport type ConvertNoteMutationResult = Apollo.MutationResult<ConvertNoteMutation>;\nexport type ConvertNoteMutationOptions = Apollo.BaseMutationOptions<ConvertNoteMutation, ConvertNoteMutationVariables>;\nexport const ConvertNoteManualDocument: TypedDocumentNode<ConvertNoteManualMutation, ConvertNoteManualMutationVariables> = gql`\n  mutation convertNoteManual($noteId: UUID!, $sharetypeId: UUID!, $conversionShares: BigInt!, $totalAmountPaid: CakeDecimal!, $date: Date) {\n  convertNoteManual(\n    noteId: $noteId\n    sharetypeId: $sharetypeId\n    conversionShares: $conversionShares\n    totalAmountPaid: $totalAmountPaid\n    date: $date\n  ) {\n    sharesIssued\n  }\n}\n    `;\nexport type ConvertNoteManualMutationFn = Apollo.MutationFunction<ConvertNoteManualMutation, ConvertNoteManualMutationVariables>;\n\n/**\n * __useConvertNoteManualMutation__\n *\n * To run a mutation, you first call `useConvertNoteManualMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useConvertNoteManualMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [convertNoteManualMutation, { data, loading, error }] = useConvertNoteManualMutation({\n *   variables: {\n *      noteId: // value for 'noteId'\n *      sharetypeId: // value for 'sharetypeId'\n *      conversionShares: // value for 'conversionShares'\n *      totalAmountPaid: // value for 'totalAmountPaid'\n *      date: // value for 'date'\n *   },\n * });\n */\nexport function useConvertNoteManualMutation(baseOptions?: Apollo.MutationHookOptions<ConvertNoteManualMutation, ConvertNoteManualMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ConvertNoteManualMutation, ConvertNoteManualMutationVariables>(ConvertNoteManualDocument, options);\n      }\nexport type ConvertNoteManualMutationHookResult = ReturnType<typeof useConvertNoteManualMutation>;\nexport type ConvertNoteManualMutationResult = Apollo.MutationResult<ConvertNoteManualMutation>;\nexport type ConvertNoteManualMutationOptions = Apollo.BaseMutationOptions<ConvertNoteManualMutation, ConvertNoteManualMutationVariables>;\nexport const CancelNoteDocument: TypedDocumentNode<CancelNoteMutation, CancelNoteMutationVariables> = gql`\n  mutation cancelNote($noteId: UUID!, $cancellationType: CleanString, $date: Date) {\n  cancelNote(noteId: $noteId, cancellationType: $cancellationType, date: $date) {\n    ok\n  }\n}\n    `;\nexport type CancelNoteMutationFn = Apollo.MutationFunction<CancelNoteMutation, CancelNoteMutationVariables>;\n\n/**\n * __useCancelNoteMutation__\n *\n * To run a mutation, you first call `useCancelNoteMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCancelNoteMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [cancelNoteMutation, { data, loading, error }] = useCancelNoteMutation({\n *   variables: {\n *      noteId: // value for 'noteId'\n *      cancellationType: // value for 'cancellationType'\n *      date: // value for 'date'\n *   },\n * });\n */\nexport function useCancelNoteMutation(baseOptions?: Apollo.MutationHookOptions<CancelNoteMutation, CancelNoteMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CancelNoteMutation, CancelNoteMutationVariables>(CancelNoteDocument, options);\n      }\nexport type CancelNoteMutationHookResult = ReturnType<typeof useCancelNoteMutation>;\nexport type CancelNoteMutationResult = Apollo.MutationResult<CancelNoteMutation>;\nexport type CancelNoteMutationOptions = Apollo.BaseMutationOptions<CancelNoteMutation, CancelNoteMutationVariables>;\nexport const SignNoteAgreementOfficeholderDocument: TypedDocumentNode<SignNoteAgreementOfficeholderMutation, SignNoteAgreementOfficeholderMutationVariables> = gql`\n  mutation signNoteAgreementOfficeholder($offerId: UUID!) {\n  signNoteAgreementOfficeholder(offerId: $offerId) {\n    urlList\n    signatureRequestId\n    expectedCallbackUrl\n  }\n}\n    `;\nexport type SignNoteAgreementOfficeholderMutationFn = Apollo.MutationFunction<SignNoteAgreementOfficeholderMutation, SignNoteAgreementOfficeholderMutationVariables>;\n\n/**\n * __useSignNoteAgreementOfficeholderMutation__\n *\n * To run a mutation, you first call `useSignNoteAgreementOfficeholderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSignNoteAgreementOfficeholderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [signNoteAgreementOfficeholderMutation, { data, loading, error }] = useSignNoteAgreementOfficeholderMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useSignNoteAgreementOfficeholderMutation(baseOptions?: Apollo.MutationHookOptions<SignNoteAgreementOfficeholderMutation, SignNoteAgreementOfficeholderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SignNoteAgreementOfficeholderMutation, SignNoteAgreementOfficeholderMutationVariables>(SignNoteAgreementOfficeholderDocument, options);\n      }\nexport type SignNoteAgreementOfficeholderMutationHookResult = ReturnType<typeof useSignNoteAgreementOfficeholderMutation>;\nexport type SignNoteAgreementOfficeholderMutationResult = Apollo.MutationResult<SignNoteAgreementOfficeholderMutation>;\nexport type SignNoteAgreementOfficeholderMutationOptions = Apollo.BaseMutationOptions<SignNoteAgreementOfficeholderMutation, SignNoteAgreementOfficeholderMutationVariables>;\nexport const ShareholdersWithNoteholdingsDocument: TypedDocumentNode<ShareholdersWithNoteholdingsQuery, ShareholdersWithNoteholdingsQueryVariables> = gql`\n  query shareholdersWithNoteholdings($organisationId: UUID!, $search: String, $page: Int, $itemsPerPage: Int) {\n  sharetypes(organisationId: $organisationId) {\n    id\n  }\n  shareholdersWithNoteholdings(\n    organisationId: $organisationId\n    search: $search\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    notSignedUpCount\n    pageData {\n      id\n      displayName\n      secondaryName\n      avatar\n      hasLoggedIn\n      consideredInvited\n      recipient {\n        id\n        displayName\n      }\n      investorData {\n        name\n        email\n        companyData {\n          contactPerson\n        }\n      }\n      trust {\n        id\n      }\n      notes: noteSet {\n        id\n        resolution\n        noteType: type\n        principal\n        discountRate\n        maturityDate\n        interestRate\n        issueDate\n        valuationCap\n      }\n    }\n  }\n  organisation(organisationId: $organisationId) {\n    fundingPhase\n  }\n}\n    `;\n\n/**\n * __useShareholdersWithNoteholdingsQuery__\n *\n * To run a query within a React component, call `useShareholdersWithNoteholdingsQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareholdersWithNoteholdingsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareholdersWithNoteholdingsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      search: // value for 'search'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useShareholdersWithNoteholdingsQuery(baseOptions: Apollo.QueryHookOptions<ShareholdersWithNoteholdingsQuery, ShareholdersWithNoteholdingsQueryVariables> & ({ variables: ShareholdersWithNoteholdingsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareholdersWithNoteholdingsQuery, ShareholdersWithNoteholdingsQueryVariables>(ShareholdersWithNoteholdingsDocument, options);\n      }\nexport function useShareholdersWithNoteholdingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareholdersWithNoteholdingsQuery, ShareholdersWithNoteholdingsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareholdersWithNoteholdingsQuery, ShareholdersWithNoteholdingsQueryVariables>(ShareholdersWithNoteholdingsDocument, options);\n        }\nexport function useShareholdersWithNoteholdingsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareholdersWithNoteholdingsQuery, ShareholdersWithNoteholdingsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareholdersWithNoteholdingsQuery, ShareholdersWithNoteholdingsQueryVariables>(ShareholdersWithNoteholdingsDocument, options);\n        }\nexport type ShareholdersWithNoteholdingsQueryHookResult = ReturnType<typeof useShareholdersWithNoteholdingsQuery>;\nexport type ShareholdersWithNoteholdingsLazyQueryHookResult = ReturnType<typeof useShareholdersWithNoteholdingsLazyQuery>;\nexport type ShareholdersWithNoteholdingsSuspenseQueryHookResult = ReturnType<typeof useShareholdersWithNoteholdingsSuspenseQuery>;\nexport type ShareholdersWithNoteholdingsQueryResult = Apollo.QueryResult<ShareholdersWithNoteholdingsQuery, ShareholdersWithNoteholdingsQueryVariables>;\nexport function refetchShareholdersWithNoteholdingsQuery(variables: ShareholdersWithNoteholdingsQueryVariables) {\n      return { query: ShareholdersWithNoteholdingsDocument, variables: variables };\n    }\nexport const CreateNotesRaiseAndOfficeholdersDocument: TypedDocumentNode<CreateNotesRaiseAndOfficeholdersMutation, CreateNotesRaiseAndOfficeholdersMutationVariables> = gql`\n  mutation createNotesRaiseAndOfficeholders($organisation: OrganisationCakeType!, $name: CleanString!, $noteType: String!, $roundInvestmentGoal: CakeDecimal!, $endDate: Date!, $signers: [OfficeholderInput!]!, $capitalRaisingEventAmount: CakeDecimal, $discountRate: CakeDecimal, $valuationCap: CakeDecimal, $interest: Interest, $maturityDate: Date, $payment: JSONString) {\n  createNotesRaiseAndOfficeholders(\n    organisation: $organisation\n    name: $name\n    noteType: $noteType\n    roundInvestmentGoal: $roundInvestmentGoal\n    endDate: $endDate\n    signers: $signers\n    capitalRaisingEventAmount: $capitalRaisingEventAmount\n    discountRate: $discountRate\n    valuationCap: $valuationCap\n    interest: $interest\n    maturityDate: $maturityDate\n    payment: $payment\n  ) {\n    notesRound {\n      id\n    }\n  }\n}\n    `;\nexport type CreateNotesRaiseAndOfficeholdersMutationFn = Apollo.MutationFunction<CreateNotesRaiseAndOfficeholdersMutation, CreateNotesRaiseAndOfficeholdersMutationVariables>;\n\n/**\n * __useCreateNotesRaiseAndOfficeholdersMutation__\n *\n * To run a mutation, you first call `useCreateNotesRaiseAndOfficeholdersMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateNotesRaiseAndOfficeholdersMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createNotesRaiseAndOfficeholdersMutation, { data, loading, error }] = useCreateNotesRaiseAndOfficeholdersMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      name: // value for 'name'\n *      noteType: // value for 'noteType'\n *      roundInvestmentGoal: // value for 'roundInvestmentGoal'\n *      endDate: // value for 'endDate'\n *      signers: // value for 'signers'\n *      capitalRaisingEventAmount: // value for 'capitalRaisingEventAmount'\n *      discountRate: // value for 'discountRate'\n *      valuationCap: // value for 'valuationCap'\n *      interest: // value for 'interest'\n *      maturityDate: // value for 'maturityDate'\n *      payment: // value for 'payment'\n *   },\n * });\n */\nexport function useCreateNotesRaiseAndOfficeholdersMutation(baseOptions?: Apollo.MutationHookOptions<CreateNotesRaiseAndOfficeholdersMutation, CreateNotesRaiseAndOfficeholdersMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateNotesRaiseAndOfficeholdersMutation, CreateNotesRaiseAndOfficeholdersMutationVariables>(CreateNotesRaiseAndOfficeholdersDocument, options);\n      }\nexport type CreateNotesRaiseAndOfficeholdersMutationHookResult = ReturnType<typeof useCreateNotesRaiseAndOfficeholdersMutation>;\nexport type CreateNotesRaiseAndOfficeholdersMutationResult = Apollo.MutationResult<CreateNotesRaiseAndOfficeholdersMutation>;\nexport type CreateNotesRaiseAndOfficeholdersMutationOptions = Apollo.BaseMutationOptions<CreateNotesRaiseAndOfficeholdersMutation, CreateNotesRaiseAndOfficeholdersMutationVariables>;\nexport const BulkDeleteNotesDocument: TypedDocumentNode<BulkDeleteNotesMutation, BulkDeleteNotesMutationVariables> = gql`\n  mutation bulkDeleteNotes($organisation: OrganisationCakeType!, $noteIds: [UUID!]!) {\n  bulkDeleteNotes(organisation: $organisation, noteIds: $noteIds)\n}\n    `;\nexport type BulkDeleteNotesMutationFn = Apollo.MutationFunction<BulkDeleteNotesMutation, BulkDeleteNotesMutationVariables>;\n\n/**\n * __useBulkDeleteNotesMutation__\n *\n * To run a mutation, you first call `useBulkDeleteNotesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useBulkDeleteNotesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [bulkDeleteNotesMutation, { data, loading, error }] = useBulkDeleteNotesMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      noteIds: // value for 'noteIds'\n *   },\n * });\n */\nexport function useBulkDeleteNotesMutation(baseOptions?: Apollo.MutationHookOptions<BulkDeleteNotesMutation, BulkDeleteNotesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<BulkDeleteNotesMutation, BulkDeleteNotesMutationVariables>(BulkDeleteNotesDocument, options);\n      }\nexport type BulkDeleteNotesMutationHookResult = ReturnType<typeof useBulkDeleteNotesMutation>;\nexport type BulkDeleteNotesMutationResult = Apollo.MutationResult<BulkDeleteNotesMutation>;\nexport type BulkDeleteNotesMutationOptions = Apollo.BaseMutationOptions<BulkDeleteNotesMutation, BulkDeleteNotesMutationVariables>;\nexport const GetOffboardingsDocument: TypedDocumentNode<GetOffboardingsQuery, GetOffboardingsQueryVariables> = gql`\n  query getOffboardings($organisationId: OrganisationCakeType!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!) {\n  offboardings(\n    organisation: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    pageData {\n      id\n      shareholder {\n        id\n        displayName\n        avatar\n        investorData {\n          email\n        }\n        employeeData {\n          level\n          role\n        }\n      }\n      terminationDate\n      status\n    }\n    currentPage\n    count\n  }\n}\n    `;\n\n/**\n * __useGetOffboardingsQuery__\n *\n * To run a query within a React component, call `useGetOffboardingsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOffboardingsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOffboardingsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetOffboardingsQuery(baseOptions: Apollo.QueryHookOptions<GetOffboardingsQuery, GetOffboardingsQueryVariables> & ({ variables: GetOffboardingsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOffboardingsQuery, GetOffboardingsQueryVariables>(GetOffboardingsDocument, options);\n      }\nexport function useGetOffboardingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOffboardingsQuery, GetOffboardingsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOffboardingsQuery, GetOffboardingsQueryVariables>(GetOffboardingsDocument, options);\n        }\nexport function useGetOffboardingsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOffboardingsQuery, GetOffboardingsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOffboardingsQuery, GetOffboardingsQueryVariables>(GetOffboardingsDocument, options);\n        }\nexport type GetOffboardingsQueryHookResult = ReturnType<typeof useGetOffboardingsQuery>;\nexport type GetOffboardingsLazyQueryHookResult = ReturnType<typeof useGetOffboardingsLazyQuery>;\nexport type GetOffboardingsSuspenseQueryHookResult = ReturnType<typeof useGetOffboardingsSuspenseQuery>;\nexport type GetOffboardingsQueryResult = Apollo.QueryResult<GetOffboardingsQuery, GetOffboardingsQueryVariables>;\nexport function refetchGetOffboardingsQuery(variables: GetOffboardingsQueryVariables) {\n      return { query: GetOffboardingsDocument, variables: variables };\n    }\nexport const CreateOffboardingDocument: TypedDocumentNode<CreateOffboardingMutation, CreateOffboardingMutationVariables> = gql`\n  mutation createOffboarding($shareholderId: ShareholderCakeType!, $terminationDate: Date!, $offers: [OffboardingEntryInputType!]!) {\n  createOffboarding(\n    shareholder: $shareholderId\n    terminationDate: $terminationDate\n    offers: $offers\n  )\n}\n    `;\nexport type CreateOffboardingMutationFn = Apollo.MutationFunction<CreateOffboardingMutation, CreateOffboardingMutationVariables>;\n\n/**\n * __useCreateOffboardingMutation__\n *\n * To run a mutation, you first call `useCreateOffboardingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateOffboardingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createOffboardingMutation, { data, loading, error }] = useCreateOffboardingMutation({\n *   variables: {\n *      shareholderId: // value for 'shareholderId'\n *      terminationDate: // value for 'terminationDate'\n *      offers: // value for 'offers'\n *   },\n * });\n */\nexport function useCreateOffboardingMutation(baseOptions?: Apollo.MutationHookOptions<CreateOffboardingMutation, CreateOffboardingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateOffboardingMutation, CreateOffboardingMutationVariables>(CreateOffboardingDocument, options);\n      }\nexport type CreateOffboardingMutationHookResult = ReturnType<typeof useCreateOffboardingMutation>;\nexport type CreateOffboardingMutationResult = Apollo.MutationResult<CreateOffboardingMutation>;\nexport type CreateOffboardingMutationOptions = Apollo.BaseMutationOptions<CreateOffboardingMutation, CreateOffboardingMutationVariables>;\nexport const DeleteOffboardingDocument: TypedDocumentNode<DeleteOffboardingMutation, DeleteOffboardingMutationVariables> = gql`\n  mutation deleteOffboarding($offboardingId: OffboardingCakeType!) {\n  deleteOffboarding(offboarding: $offboardingId)\n}\n    `;\nexport type DeleteOffboardingMutationFn = Apollo.MutationFunction<DeleteOffboardingMutation, DeleteOffboardingMutationVariables>;\n\n/**\n * __useDeleteOffboardingMutation__\n *\n * To run a mutation, you first call `useDeleteOffboardingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteOffboardingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteOffboardingMutation, { data, loading, error }] = useDeleteOffboardingMutation({\n *   variables: {\n *      offboardingId: // value for 'offboardingId'\n *   },\n * });\n */\nexport function useDeleteOffboardingMutation(baseOptions?: Apollo.MutationHookOptions<DeleteOffboardingMutation, DeleteOffboardingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteOffboardingMutation, DeleteOffboardingMutationVariables>(DeleteOffboardingDocument, options);\n      }\nexport type DeleteOffboardingMutationHookResult = ReturnType<typeof useDeleteOffboardingMutation>;\nexport type DeleteOffboardingMutationResult = Apollo.MutationResult<DeleteOffboardingMutation>;\nexport type DeleteOffboardingMutationOptions = Apollo.BaseMutationOptions<DeleteOffboardingMutation, DeleteOffboardingMutationVariables>;\nexport const ShareholdersToOffboardDocument: TypedDocumentNode<ShareholdersToOffboardQuery, ShareholdersToOffboardQueryVariables> = gql`\n  query ShareholdersToOffboard($organisationId: UUID!, $page: Int!, $itemsPerPage: Int!, $search: String, $shareholderIdsToExclude: [UUID]) {\n  shareholdersToOffboard(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    search: $search\n    excludeByIds: $shareholderIdsToExclude\n  ) {\n    notSignedUpCount\n    count\n    currentPage\n    pageData {\n      id\n      displayName\n      avatar\n      investorData {\n        email\n      }\n      employeeData {\n        role\n        level\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useShareholdersToOffboardQuery__\n *\n * To run a query within a React component, call `useShareholdersToOffboardQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareholdersToOffboardQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareholdersToOffboardQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      search: // value for 'search'\n *      shareholderIdsToExclude: // value for 'shareholderIdsToExclude'\n *   },\n * });\n */\nexport function useShareholdersToOffboardQuery(baseOptions: Apollo.QueryHookOptions<ShareholdersToOffboardQuery, ShareholdersToOffboardQueryVariables> & ({ variables: ShareholdersToOffboardQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareholdersToOffboardQuery, ShareholdersToOffboardQueryVariables>(ShareholdersToOffboardDocument, options);\n      }\nexport function useShareholdersToOffboardLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareholdersToOffboardQuery, ShareholdersToOffboardQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareholdersToOffboardQuery, ShareholdersToOffboardQueryVariables>(ShareholdersToOffboardDocument, options);\n        }\nexport function useShareholdersToOffboardSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareholdersToOffboardQuery, ShareholdersToOffboardQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareholdersToOffboardQuery, ShareholdersToOffboardQueryVariables>(ShareholdersToOffboardDocument, options);\n        }\nexport type ShareholdersToOffboardQueryHookResult = ReturnType<typeof useShareholdersToOffboardQuery>;\nexport type ShareholdersToOffboardLazyQueryHookResult = ReturnType<typeof useShareholdersToOffboardLazyQuery>;\nexport type ShareholdersToOffboardSuspenseQueryHookResult = ReturnType<typeof useShareholdersToOffboardSuspenseQuery>;\nexport type ShareholdersToOffboardQueryResult = Apollo.QueryResult<ShareholdersToOffboardQuery, ShareholdersToOffboardQueryVariables>;\nexport function refetchShareholdersToOffboardQuery(variables: ShareholdersToOffboardQueryVariables) {\n      return { query: ShareholdersToOffboardDocument, variables: variables };\n    }\nexport const ShareholderOffboardingOffersDocument: TypedDocumentNode<ShareholderOffboardingOffersQuery, ShareholderOffboardingOffersQueryVariables> = gql`\n  query shareholderOffboardingOffers($shareholderId: ShareholderCakeType!, $offboardingDate: Date!) {\n  shareholderOffboardingOffers(\n    shareholder: $shareholderId\n    offboardingDate: $offboardingDate\n  ) {\n    shareholder {\n      id\n      displayName\n      avatar\n      investorData {\n        email\n      }\n      employeeData {\n        level\n        role\n      }\n    }\n    esopOffers {\n      id\n    }\n    essOffers {\n      id\n    }\n    rsuOffers {\n      id\n    }\n    founderVestingOffers {\n      id\n    }\n  }\n}\n    `;\n\n/**\n * __useShareholderOffboardingOffersQuery__\n *\n * To run a query within a React component, call `useShareholderOffboardingOffersQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareholderOffboardingOffersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareholderOffboardingOffersQuery({\n *   variables: {\n *      shareholderId: // value for 'shareholderId'\n *      offboardingDate: // value for 'offboardingDate'\n *   },\n * });\n */\nexport function useShareholderOffboardingOffersQuery(baseOptions: Apollo.QueryHookOptions<ShareholderOffboardingOffersQuery, ShareholderOffboardingOffersQueryVariables> & ({ variables: ShareholderOffboardingOffersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareholderOffboardingOffersQuery, ShareholderOffboardingOffersQueryVariables>(ShareholderOffboardingOffersDocument, options);\n      }\nexport function useShareholderOffboardingOffersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareholderOffboardingOffersQuery, ShareholderOffboardingOffersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareholderOffboardingOffersQuery, ShareholderOffboardingOffersQueryVariables>(ShareholderOffboardingOffersDocument, options);\n        }\nexport function useShareholderOffboardingOffersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareholderOffboardingOffersQuery, ShareholderOffboardingOffersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareholderOffboardingOffersQuery, ShareholderOffboardingOffersQueryVariables>(ShareholderOffboardingOffersDocument, options);\n        }\nexport type ShareholderOffboardingOffersQueryHookResult = ReturnType<typeof useShareholderOffboardingOffersQuery>;\nexport type ShareholderOffboardingOffersLazyQueryHookResult = ReturnType<typeof useShareholderOffboardingOffersLazyQuery>;\nexport type ShareholderOffboardingOffersSuspenseQueryHookResult = ReturnType<typeof useShareholderOffboardingOffersSuspenseQuery>;\nexport type ShareholderOffboardingOffersQueryResult = Apollo.QueryResult<ShareholderOffboardingOffersQuery, ShareholderOffboardingOffersQueryVariables>;\nexport function refetchShareholderOffboardingOffersQuery(variables: ShareholderOffboardingOffersQueryVariables) {\n      return { query: ShareholderOffboardingOffersDocument, variables: variables };\n    }\nexport const OffboardingDetailsEsopDocument: TypedDocumentNode<OffboardingDetailsEsopQuery, OffboardingDetailsEsopQueryVariables> = gql`\n  query offboardingDetailsEsop($offerId: EsopOfferCakeType!) {\n  offboardingDetailsEsop(offer: $offerId) {\n    id\n    granted\n    exercised\n    vestablePeriodic\n    vestableMilestone\n    vestedPeriodic\n    vestedMilestone\n    lapsedMilestone\n    lapsedPeriodic\n    availableToExercise\n    availableToVest\n    availableToLapse\n    conversionLockDate\n    country\n    currency\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        entryType\n      }\n    }\n    vestingEvents {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: esoptransactionSet {\n        id\n        transactionDate\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n        reminderDate\n      }\n    }\n    offboardSettings {\n      id\n      accelerateAmount\n      fullyLapse\n      stopVestingAt\n      repurchaseValueUnvested\n      repurchaseValueVested\n      autoLapse\n      complete\n    }\n    ptepSettings {\n      id\n      ptepInterval {\n        quantity\n        unit\n      }\n      sendExerciseReminder\n    }\n  }\n}\n    `;\n\n/**\n * __useOffboardingDetailsEsopQuery__\n *\n * To run a query within a React component, call `useOffboardingDetailsEsopQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffboardingDetailsEsopQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffboardingDetailsEsopQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useOffboardingDetailsEsopQuery(baseOptions: Apollo.QueryHookOptions<OffboardingDetailsEsopQuery, OffboardingDetailsEsopQueryVariables> & ({ variables: OffboardingDetailsEsopQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffboardingDetailsEsopQuery, OffboardingDetailsEsopQueryVariables>(OffboardingDetailsEsopDocument, options);\n      }\nexport function useOffboardingDetailsEsopLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffboardingDetailsEsopQuery, OffboardingDetailsEsopQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffboardingDetailsEsopQuery, OffboardingDetailsEsopQueryVariables>(OffboardingDetailsEsopDocument, options);\n        }\nexport function useOffboardingDetailsEsopSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffboardingDetailsEsopQuery, OffboardingDetailsEsopQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffboardingDetailsEsopQuery, OffboardingDetailsEsopQueryVariables>(OffboardingDetailsEsopDocument, options);\n        }\nexport type OffboardingDetailsEsopQueryHookResult = ReturnType<typeof useOffboardingDetailsEsopQuery>;\nexport type OffboardingDetailsEsopLazyQueryHookResult = ReturnType<typeof useOffboardingDetailsEsopLazyQuery>;\nexport type OffboardingDetailsEsopSuspenseQueryHookResult = ReturnType<typeof useOffboardingDetailsEsopSuspenseQuery>;\nexport type OffboardingDetailsEsopQueryResult = Apollo.QueryResult<OffboardingDetailsEsopQuery, OffboardingDetailsEsopQueryVariables>;\nexport function refetchOffboardingDetailsEsopQuery(variables: OffboardingDetailsEsopQueryVariables) {\n      return { query: OffboardingDetailsEsopDocument, variables: variables };\n    }\nexport const OffboardingDetailsEssDocument: TypedDocumentNode<OffboardingDetailsEssQuery, OffboardingDetailsEssQueryVariables> = gql`\n  query offboardingDetailsEss($offerId: EssOfferCakeType!) {\n  offboardingDetailsEss(offer: $offerId) {\n    id\n    granted\n    exercised\n    vestablePeriodic\n    vestableMilestone\n    vestedPeriodic\n    vestedMilestone\n    lapsedMilestone\n    lapsedPeriodic\n    availableToExercise\n    availableToVest\n    availableToLapse\n    conversionLockDate\n    country\n    currency\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        entryType\n      }\n    }\n    vestingEvents {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: esstransactionSet {\n        id\n        transactionDate\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n        reminderDate\n      }\n    }\n    offboardSettings {\n      id\n      accelerateAmount\n      fullyLapse\n      stopVestingAt\n      repurchaseValueUnvested\n      repurchaseValueVested\n      autoLapse\n      complete\n    }\n  }\n}\n    `;\n\n/**\n * __useOffboardingDetailsEssQuery__\n *\n * To run a query within a React component, call `useOffboardingDetailsEssQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffboardingDetailsEssQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffboardingDetailsEssQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useOffboardingDetailsEssQuery(baseOptions: Apollo.QueryHookOptions<OffboardingDetailsEssQuery, OffboardingDetailsEssQueryVariables> & ({ variables: OffboardingDetailsEssQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffboardingDetailsEssQuery, OffboardingDetailsEssQueryVariables>(OffboardingDetailsEssDocument, options);\n      }\nexport function useOffboardingDetailsEssLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffboardingDetailsEssQuery, OffboardingDetailsEssQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffboardingDetailsEssQuery, OffboardingDetailsEssQueryVariables>(OffboardingDetailsEssDocument, options);\n        }\nexport function useOffboardingDetailsEssSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffboardingDetailsEssQuery, OffboardingDetailsEssQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffboardingDetailsEssQuery, OffboardingDetailsEssQueryVariables>(OffboardingDetailsEssDocument, options);\n        }\nexport type OffboardingDetailsEssQueryHookResult = ReturnType<typeof useOffboardingDetailsEssQuery>;\nexport type OffboardingDetailsEssLazyQueryHookResult = ReturnType<typeof useOffboardingDetailsEssLazyQuery>;\nexport type OffboardingDetailsEssSuspenseQueryHookResult = ReturnType<typeof useOffboardingDetailsEssSuspenseQuery>;\nexport type OffboardingDetailsEssQueryResult = Apollo.QueryResult<OffboardingDetailsEssQuery, OffboardingDetailsEssQueryVariables>;\nexport function refetchOffboardingDetailsEssQuery(variables: OffboardingDetailsEssQueryVariables) {\n      return { query: OffboardingDetailsEssDocument, variables: variables };\n    }\nexport const OffboardingDetailsRsuDocument: TypedDocumentNode<OffboardingDetailsRsuQuery, OffboardingDetailsRsuQueryVariables> = gql`\n  query offboardingDetailsRsu($offerId: RsuOfferCakeType!) {\n  offboardingDetailsRsu(offer: $offerId) {\n    id\n    granted\n    exercised\n    vestablePeriodic\n    vestableMilestone\n    vestedPeriodic\n    vestedMilestone\n    lapsedMilestone\n    lapsedPeriodic\n    availableToExercise\n    availableToVest\n    availableToLapse\n    conversionLockDate\n    country\n    currency\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        entryType\n      }\n    }\n    vestingEvents {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: rsutransactionSet {\n        id\n        transactionDate\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n        reminderDate\n      }\n    }\n    offboardSettings {\n      id\n      accelerateAmount\n      fullyLapse\n      stopVestingAt\n      repurchaseValueUnvested\n      repurchaseValueVested\n      autoLapse\n      complete\n    }\n  }\n}\n    `;\n\n/**\n * __useOffboardingDetailsRsuQuery__\n *\n * To run a query within a React component, call `useOffboardingDetailsRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffboardingDetailsRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffboardingDetailsRsuQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useOffboardingDetailsRsuQuery(baseOptions: Apollo.QueryHookOptions<OffboardingDetailsRsuQuery, OffboardingDetailsRsuQueryVariables> & ({ variables: OffboardingDetailsRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffboardingDetailsRsuQuery, OffboardingDetailsRsuQueryVariables>(OffboardingDetailsRsuDocument, options);\n      }\nexport function useOffboardingDetailsRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffboardingDetailsRsuQuery, OffboardingDetailsRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffboardingDetailsRsuQuery, OffboardingDetailsRsuQueryVariables>(OffboardingDetailsRsuDocument, options);\n        }\nexport function useOffboardingDetailsRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffboardingDetailsRsuQuery, OffboardingDetailsRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffboardingDetailsRsuQuery, OffboardingDetailsRsuQueryVariables>(OffboardingDetailsRsuDocument, options);\n        }\nexport type OffboardingDetailsRsuQueryHookResult = ReturnType<typeof useOffboardingDetailsRsuQuery>;\nexport type OffboardingDetailsRsuLazyQueryHookResult = ReturnType<typeof useOffboardingDetailsRsuLazyQuery>;\nexport type OffboardingDetailsRsuSuspenseQueryHookResult = ReturnType<typeof useOffboardingDetailsRsuSuspenseQuery>;\nexport type OffboardingDetailsRsuQueryResult = Apollo.QueryResult<OffboardingDetailsRsuQuery, OffboardingDetailsRsuQueryVariables>;\nexport function refetchOffboardingDetailsRsuQuery(variables: OffboardingDetailsRsuQueryVariables) {\n      return { query: OffboardingDetailsRsuDocument, variables: variables };\n    }\nexport const OffboardingDetailsFounderVestingDocument: TypedDocumentNode<OffboardingDetailsFounderVestingQuery, OffboardingDetailsFounderVestingQueryVariables> = gql`\n  query offboardingDetailsFounderVesting($offerId: FounderVestingOfferCakeType!) {\n  offboardingDetailsFounderVesting(offer: $offerId) {\n    id\n    granted\n    exercised\n    vestablePeriodic\n    vestableMilestone\n    vestedPeriodic\n    vestedMilestone\n    lapsedMilestone\n    lapsedPeriodic\n    availableToExercise\n    availableToVest\n    availableToLapse\n    conversionLockDate\n    country\n    currency\n    calendar {\n      entries {\n        date\n        accumulated\n        vestingValue\n        entryType\n      }\n    }\n    vestingEvents {\n      id\n      order\n      vestingValue\n      eventType\n      transactionSet: foundervestingtransactionSet {\n        id\n        transactionDate\n        vestingValue\n        type\n      }\n      vestingData {\n        description\n        duration {\n          value\n          granularity\n        }\n        frequency {\n          value\n          granularity\n        }\n        reminderDate\n      }\n    }\n    offboardSettings {\n      id\n      accelerateAmount\n      fullyLapse\n      stopVestingAt\n      repurchaseValueUnvested\n      repurchaseValueVested\n      autoLapse\n      complete\n    }\n  }\n}\n    `;\n\n/**\n * __useOffboardingDetailsFounderVestingQuery__\n *\n * To run a query within a React component, call `useOffboardingDetailsFounderVestingQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffboardingDetailsFounderVestingQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffboardingDetailsFounderVestingQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useOffboardingDetailsFounderVestingQuery(baseOptions: Apollo.QueryHookOptions<OffboardingDetailsFounderVestingQuery, OffboardingDetailsFounderVestingQueryVariables> & ({ variables: OffboardingDetailsFounderVestingQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffboardingDetailsFounderVestingQuery, OffboardingDetailsFounderVestingQueryVariables>(OffboardingDetailsFounderVestingDocument, options);\n      }\nexport function useOffboardingDetailsFounderVestingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffboardingDetailsFounderVestingQuery, OffboardingDetailsFounderVestingQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffboardingDetailsFounderVestingQuery, OffboardingDetailsFounderVestingQueryVariables>(OffboardingDetailsFounderVestingDocument, options);\n        }\nexport function useOffboardingDetailsFounderVestingSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffboardingDetailsFounderVestingQuery, OffboardingDetailsFounderVestingQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffboardingDetailsFounderVestingQuery, OffboardingDetailsFounderVestingQueryVariables>(OffboardingDetailsFounderVestingDocument, options);\n        }\nexport type OffboardingDetailsFounderVestingQueryHookResult = ReturnType<typeof useOffboardingDetailsFounderVestingQuery>;\nexport type OffboardingDetailsFounderVestingLazyQueryHookResult = ReturnType<typeof useOffboardingDetailsFounderVestingLazyQuery>;\nexport type OffboardingDetailsFounderVestingSuspenseQueryHookResult = ReturnType<typeof useOffboardingDetailsFounderVestingSuspenseQuery>;\nexport type OffboardingDetailsFounderVestingQueryResult = Apollo.QueryResult<OffboardingDetailsFounderVestingQuery, OffboardingDetailsFounderVestingQueryVariables>;\nexport function refetchOffboardingDetailsFounderVestingQuery(variables: OffboardingDetailsFounderVestingQueryVariables) {\n      return { query: OffboardingDetailsFounderVestingDocument, variables: variables };\n    }\nexport const OffboardingDocument: TypedDocumentNode<OffboardingQuery, OffboardingQueryVariables> = gql`\n  query offboarding($offboardingId: OffboardingCakeType!) {\n  offboarding(offboarding: $offboardingId) {\n    id\n    shareholder {\n      id\n      displayName\n      avatar\n      investorData {\n        email\n      }\n      employeeData {\n        level\n        role\n      }\n    }\n    terminationDate\n    offboardeventsettingsSet {\n      id\n      accelerateAmount\n      fullyLapse\n      stopVestingAt\n      repurchaseValueUnvested\n      repurchaseValueVested\n      essoffer {\n        id\n      }\n      esopoffer {\n        id\n      }\n      rsuoffer {\n        id\n      }\n      foundervestingoffer {\n        id\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useOffboardingQuery__\n *\n * To run a query within a React component, call `useOffboardingQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffboardingQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffboardingQuery({\n *   variables: {\n *      offboardingId: // value for 'offboardingId'\n *   },\n * });\n */\nexport function useOffboardingQuery(baseOptions: Apollo.QueryHookOptions<OffboardingQuery, OffboardingQueryVariables> & ({ variables: OffboardingQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffboardingQuery, OffboardingQueryVariables>(OffboardingDocument, options);\n      }\nexport function useOffboardingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffboardingQuery, OffboardingQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffboardingQuery, OffboardingQueryVariables>(OffboardingDocument, options);\n        }\nexport function useOffboardingSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffboardingQuery, OffboardingQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffboardingQuery, OffboardingQueryVariables>(OffboardingDocument, options);\n        }\nexport type OffboardingQueryHookResult = ReturnType<typeof useOffboardingQuery>;\nexport type OffboardingLazyQueryHookResult = ReturnType<typeof useOffboardingLazyQuery>;\nexport type OffboardingSuspenseQueryHookResult = ReturnType<typeof useOffboardingSuspenseQuery>;\nexport type OffboardingQueryResult = Apollo.QueryResult<OffboardingQuery, OffboardingQueryVariables>;\nexport function refetchOffboardingQuery(variables: OffboardingQueryVariables) {\n      return { query: OffboardingDocument, variables: variables };\n    }\nexport const EditOffboardingDocument: TypedDocumentNode<EditOffboardingMutation, EditOffboardingMutationVariables> = gql`\n  mutation editOffboarding($offboardingId: OffboardingCakeType!, $terminationDate: Date!, $offers: [OffboardingEntryInputType!]!) {\n  editOffboarding(\n    offboarding: $offboardingId\n    terminationDate: $terminationDate\n    offers: $offers\n  )\n}\n    `;\nexport type EditOffboardingMutationFn = Apollo.MutationFunction<EditOffboardingMutation, EditOffboardingMutationVariables>;\n\n/**\n * __useEditOffboardingMutation__\n *\n * To run a mutation, you first call `useEditOffboardingMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditOffboardingMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editOffboardingMutation, { data, loading, error }] = useEditOffboardingMutation({\n *   variables: {\n *      offboardingId: // value for 'offboardingId'\n *      terminationDate: // value for 'terminationDate'\n *      offers: // value for 'offers'\n *   },\n * });\n */\nexport function useEditOffboardingMutation(baseOptions?: Apollo.MutationHookOptions<EditOffboardingMutation, EditOffboardingMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditOffboardingMutation, EditOffboardingMutationVariables>(EditOffboardingDocument, options);\n      }\nexport type EditOffboardingMutationHookResult = ReturnType<typeof useEditOffboardingMutation>;\nexport type EditOffboardingMutationResult = Apollo.MutationResult<EditOffboardingMutation>;\nexport type EditOffboardingMutationOptions = Apollo.BaseMutationOptions<EditOffboardingMutation, EditOffboardingMutationVariables>;\nexport const UpdateHubspotMobileNumberDocument: TypedDocumentNode<UpdateHubspotMobileNumberMutation, UpdateHubspotMobileNumberMutationVariables> = gql`\n  mutation updateHubspotMobileNumber($organisation: OrganisationCakeType!, $mobileNumber: CleanString!) {\n  updateHubspotMobileNumber(\n    organisation: $organisation\n    mobileNumber: $mobileNumber\n  )\n}\n    `;\nexport type UpdateHubspotMobileNumberMutationFn = Apollo.MutationFunction<UpdateHubspotMobileNumberMutation, UpdateHubspotMobileNumberMutationVariables>;\n\n/**\n * __useUpdateHubspotMobileNumberMutation__\n *\n * To run a mutation, you first call `useUpdateHubspotMobileNumberMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateHubspotMobileNumberMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateHubspotMobileNumberMutation, { data, loading, error }] = useUpdateHubspotMobileNumberMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      mobileNumber: // value for 'mobileNumber'\n *   },\n * });\n */\nexport function useUpdateHubspotMobileNumberMutation(baseOptions?: Apollo.MutationHookOptions<UpdateHubspotMobileNumberMutation, UpdateHubspotMobileNumberMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateHubspotMobileNumberMutation, UpdateHubspotMobileNumberMutationVariables>(UpdateHubspotMobileNumberDocument, options);\n      }\nexport type UpdateHubspotMobileNumberMutationHookResult = ReturnType<typeof useUpdateHubspotMobileNumberMutation>;\nexport type UpdateHubspotMobileNumberMutationResult = Apollo.MutationResult<UpdateHubspotMobileNumberMutation>;\nexport type UpdateHubspotMobileNumberMutationOptions = Apollo.BaseMutationOptions<UpdateHubspotMobileNumberMutation, UpdateHubspotMobileNumberMutationVariables>;\nexport const AddShareholderIssueSharesDocument: TypedDocumentNode<AddShareholderIssueSharesMutation, AddShareholderIssueSharesMutationVariables> = gql`\n  mutation addShareholderIssueShares($organisation: OrganisationCakeType!, $shareholderIssueSharesInputList: [ShareholderIssueSharesInput]!) {\n  addShareholderIssueShares(\n    organisation: $organisation\n    shareholderIssueSharesInputList: $shareholderIssueSharesInputList\n  ) {\n    id\n    investorData {\n      email\n    }\n  }\n}\n    `;\nexport type AddShareholderIssueSharesMutationFn = Apollo.MutationFunction<AddShareholderIssueSharesMutation, AddShareholderIssueSharesMutationVariables>;\n\n/**\n * __useAddShareholderIssueSharesMutation__\n *\n * To run a mutation, you first call `useAddShareholderIssueSharesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddShareholderIssueSharesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addShareholderIssueSharesMutation, { data, loading, error }] = useAddShareholderIssueSharesMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      shareholderIssueSharesInputList: // value for 'shareholderIssueSharesInputList'\n *   },\n * });\n */\nexport function useAddShareholderIssueSharesMutation(baseOptions?: Apollo.MutationHookOptions<AddShareholderIssueSharesMutation, AddShareholderIssueSharesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddShareholderIssueSharesMutation, AddShareholderIssueSharesMutationVariables>(AddShareholderIssueSharesDocument, options);\n      }\nexport type AddShareholderIssueSharesMutationHookResult = ReturnType<typeof useAddShareholderIssueSharesMutation>;\nexport type AddShareholderIssueSharesMutationResult = Apollo.MutationResult<AddShareholderIssueSharesMutation>;\nexport type AddShareholderIssueSharesMutationOptions = Apollo.BaseMutationOptions<AddShareholderIssueSharesMutation, AddShareholderIssueSharesMutationVariables>;\nexport const OnboardingShownDocument: TypedDocumentNode<OnboardingShownMutation, OnboardingShownMutationVariables> = gql`\n  mutation onboardingShown($organisation: OrganisationCakeType!) {\n  onboardingShown(organisation: $organisation)\n}\n    `;\nexport type OnboardingShownMutationFn = Apollo.MutationFunction<OnboardingShownMutation, OnboardingShownMutationVariables>;\n\n/**\n * __useOnboardingShownMutation__\n *\n * To run a mutation, you first call `useOnboardingShownMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useOnboardingShownMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [onboardingShownMutation, { data, loading, error }] = useOnboardingShownMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useOnboardingShownMutation(baseOptions?: Apollo.MutationHookOptions<OnboardingShownMutation, OnboardingShownMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<OnboardingShownMutation, OnboardingShownMutationVariables>(OnboardingShownDocument, options);\n      }\nexport type OnboardingShownMutationHookResult = ReturnType<typeof useOnboardingShownMutation>;\nexport type OnboardingShownMutationResult = Apollo.MutationResult<OnboardingShownMutation>;\nexport type OnboardingShownMutationOptions = Apollo.BaseMutationOptions<OnboardingShownMutation, OnboardingShownMutationVariables>;\nexport const GetStepAddShareholdersDataDocument: TypedDocumentNode<GetStepAddShareholdersDataQuery, GetStepAddShareholdersDataQueryVariables> = gql`\n  query getStepAddShareholdersData($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    creationIntent\n    sharetypeSet {\n      id\n      name\n      symbol\n    }\n  }\n}\n    `;\n\n/**\n * __useGetStepAddShareholdersDataQuery__\n *\n * To run a query within a React component, call `useGetStepAddShareholdersDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetStepAddShareholdersDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetStepAddShareholdersDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetStepAddShareholdersDataQuery(baseOptions: Apollo.QueryHookOptions<GetStepAddShareholdersDataQuery, GetStepAddShareholdersDataQueryVariables> & ({ variables: GetStepAddShareholdersDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetStepAddShareholdersDataQuery, GetStepAddShareholdersDataQueryVariables>(GetStepAddShareholdersDataDocument, options);\n      }\nexport function useGetStepAddShareholdersDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetStepAddShareholdersDataQuery, GetStepAddShareholdersDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetStepAddShareholdersDataQuery, GetStepAddShareholdersDataQueryVariables>(GetStepAddShareholdersDataDocument, options);\n        }\nexport function useGetStepAddShareholdersDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetStepAddShareholdersDataQuery, GetStepAddShareholdersDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetStepAddShareholdersDataQuery, GetStepAddShareholdersDataQueryVariables>(GetStepAddShareholdersDataDocument, options);\n        }\nexport type GetStepAddShareholdersDataQueryHookResult = ReturnType<typeof useGetStepAddShareholdersDataQuery>;\nexport type GetStepAddShareholdersDataLazyQueryHookResult = ReturnType<typeof useGetStepAddShareholdersDataLazyQuery>;\nexport type GetStepAddShareholdersDataSuspenseQueryHookResult = ReturnType<typeof useGetStepAddShareholdersDataSuspenseQuery>;\nexport type GetStepAddShareholdersDataQueryResult = Apollo.QueryResult<GetStepAddShareholdersDataQuery, GetStepAddShareholdersDataQueryVariables>;\nexport function refetchGetStepAddShareholdersDataQuery(variables: GetStepAddShareholdersDataQueryVariables) {\n      return { query: GetStepAddShareholdersDataDocument, variables: variables };\n    }\nexport const GetOrganisationDataDocument: TypedDocumentNode<GetOrganisationDataQuery, GetOrganisationDataQueryVariables> = gql`\n  query getOrganisationData($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    id\n    name\n    country\n    currency\n    logoImage: logoImageLink\n    fundingPhase\n    created\n    companyType: type\n    shareCertificateType\n    companyDetails {\n      ... on AuCompanyDetailsField {\n        acn\n        registrationLocation\n        registeredAgentName\n        registeredAgentEmail\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on SgCompanyDetailsField {\n        uen\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on UsCompanyDetailsField {\n        stateOfRegistration\n        ein\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on GbCompanyDetailsField {\n        crn\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on NzCompanyDetailsField {\n        nzbn\n        registeredAgentName\n        registeredAgentEmail\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on InCompanyDetailsField {\n        cin\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on CaCompanyDetailsField {\n        bn\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on EeCompanyDetailsField {\n        brc\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationDataQuery__\n *\n * To run a query within a React component, call `useGetOrganisationDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetOrganisationDataQuery(baseOptions: Apollo.QueryHookOptions<GetOrganisationDataQuery, GetOrganisationDataQueryVariables> & ({ variables: GetOrganisationDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationDataQuery, GetOrganisationDataQueryVariables>(GetOrganisationDataDocument, options);\n      }\nexport function useGetOrganisationDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationDataQuery, GetOrganisationDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationDataQuery, GetOrganisationDataQueryVariables>(GetOrganisationDataDocument, options);\n        }\nexport function useGetOrganisationDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationDataQuery, GetOrganisationDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationDataQuery, GetOrganisationDataQueryVariables>(GetOrganisationDataDocument, options);\n        }\nexport type GetOrganisationDataQueryHookResult = ReturnType<typeof useGetOrganisationDataQuery>;\nexport type GetOrganisationDataLazyQueryHookResult = ReturnType<typeof useGetOrganisationDataLazyQuery>;\nexport type GetOrganisationDataSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationDataSuspenseQuery>;\nexport type GetOrganisationDataQueryResult = Apollo.QueryResult<GetOrganisationDataQuery, GetOrganisationDataQueryVariables>;\nexport function refetchGetOrganisationDataQuery(variables: GetOrganisationDataQueryVariables) {\n      return { query: GetOrganisationDataDocument, variables: variables };\n    }\nexport const OrganisationShareholdingTransactionsDocument: TypedDocumentNode<OrganisationShareholdingTransactionsQuery, OrganisationShareholdingTransactionsQueryVariables> = gql`\n  query organisationShareholdingTransactions($organisationId: UUID!, $page: Int, $itemsPerPage: Int, $filterType: String, $faultyOnly: Boolean) {\n  organisationShareholdingTransactions(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    filterType: $filterType\n    faultyOnly: $faultyOnly\n  ) {\n    pageData {\n      transactionId: id\n      transactionDate\n      transactionType: type\n      sharetype {\n        id\n        symbol\n      }\n      shares\n      amount\n      paidInTransfer\n      shareSplitFactor\n      lastComment\n      shareholder {\n        id\n        displayName\n        secondaryName\n        avatar\n        recipient {\n          id\n          displayName\n        }\n        trust {\n          id\n        }\n        investorData {\n          name\n          address {\n            line2\n            line1\n            locality\n            administrativeArea1\n            postcode\n            country\n          }\n          companyData {\n            identifierType\n          }\n        }\n      }\n      beneficiary {\n        id\n        displayName\n      }\n      unpaid\n      error\n      certificate {\n        id\n        name\n        certificateNumber\n      }\n      attachedDocumentId\n      attachedDocumentName\n    }\n    currentPage\n    count\n  }\n  organisation(organisationId: $organisationId) {\n    shareCertificateType\n    lastCertificateNumber\n  }\n}\n    `;\n\n/**\n * __useOrganisationShareholdingTransactionsQuery__\n *\n * To run a query within a React component, call `useOrganisationShareholdingTransactionsQuery` and pass it any options that fit your needs.\n * When your component renders, `useOrganisationShareholdingTransactionsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOrganisationShareholdingTransactionsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      filterType: // value for 'filterType'\n *      faultyOnly: // value for 'faultyOnly'\n *   },\n * });\n */\nexport function useOrganisationShareholdingTransactionsQuery(baseOptions: Apollo.QueryHookOptions<OrganisationShareholdingTransactionsQuery, OrganisationShareholdingTransactionsQueryVariables> & ({ variables: OrganisationShareholdingTransactionsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OrganisationShareholdingTransactionsQuery, OrganisationShareholdingTransactionsQueryVariables>(OrganisationShareholdingTransactionsDocument, options);\n      }\nexport function useOrganisationShareholdingTransactionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OrganisationShareholdingTransactionsQuery, OrganisationShareholdingTransactionsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OrganisationShareholdingTransactionsQuery, OrganisationShareholdingTransactionsQueryVariables>(OrganisationShareholdingTransactionsDocument, options);\n        }\nexport function useOrganisationShareholdingTransactionsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OrganisationShareholdingTransactionsQuery, OrganisationShareholdingTransactionsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OrganisationShareholdingTransactionsQuery, OrganisationShareholdingTransactionsQueryVariables>(OrganisationShareholdingTransactionsDocument, options);\n        }\nexport type OrganisationShareholdingTransactionsQueryHookResult = ReturnType<typeof useOrganisationShareholdingTransactionsQuery>;\nexport type OrganisationShareholdingTransactionsLazyQueryHookResult = ReturnType<typeof useOrganisationShareholdingTransactionsLazyQuery>;\nexport type OrganisationShareholdingTransactionsSuspenseQueryHookResult = ReturnType<typeof useOrganisationShareholdingTransactionsSuspenseQuery>;\nexport type OrganisationShareholdingTransactionsQueryResult = Apollo.QueryResult<OrganisationShareholdingTransactionsQuery, OrganisationShareholdingTransactionsQueryVariables>;\nexport function refetchOrganisationShareholdingTransactionsQuery(variables: OrganisationShareholdingTransactionsQueryVariables) {\n      return { query: OrganisationShareholdingTransactionsDocument, variables: variables };\n    }\nexport const GetOrganisationNotesTransactionsDocument: TypedDocumentNode<GetOrganisationNotesTransactionsQuery, GetOrganisationNotesTransactionsQueryVariables> = gql`\n  query getOrganisationNotesTransactions($organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  organisationNotesTransactions(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    pageData {\n      transactionId: id\n      transactionDate\n      transactionType: type\n      note {\n        type\n        principal\n        interestRate\n        discountRate\n        valuationCap\n      }\n      shareholder {\n        id\n        displayName\n        secondaryName\n        avatar\n        recipient {\n          id\n          displayName\n        }\n        trust {\n          id\n        }\n        investorData {\n          name\n          companyData {\n            identifierType\n          }\n        }\n      }\n    }\n    currentPage\n    count\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationNotesTransactionsQuery__\n *\n * To run a query within a React component, call `useGetOrganisationNotesTransactionsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationNotesTransactionsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationNotesTransactionsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetOrganisationNotesTransactionsQuery(baseOptions: Apollo.QueryHookOptions<GetOrganisationNotesTransactionsQuery, GetOrganisationNotesTransactionsQueryVariables> & ({ variables: GetOrganisationNotesTransactionsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationNotesTransactionsQuery, GetOrganisationNotesTransactionsQueryVariables>(GetOrganisationNotesTransactionsDocument, options);\n      }\nexport function useGetOrganisationNotesTransactionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationNotesTransactionsQuery, GetOrganisationNotesTransactionsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationNotesTransactionsQuery, GetOrganisationNotesTransactionsQueryVariables>(GetOrganisationNotesTransactionsDocument, options);\n        }\nexport function useGetOrganisationNotesTransactionsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationNotesTransactionsQuery, GetOrganisationNotesTransactionsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationNotesTransactionsQuery, GetOrganisationNotesTransactionsQueryVariables>(GetOrganisationNotesTransactionsDocument, options);\n        }\nexport type GetOrganisationNotesTransactionsQueryHookResult = ReturnType<typeof useGetOrganisationNotesTransactionsQuery>;\nexport type GetOrganisationNotesTransactionsLazyQueryHookResult = ReturnType<typeof useGetOrganisationNotesTransactionsLazyQuery>;\nexport type GetOrganisationNotesTransactionsSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationNotesTransactionsSuspenseQuery>;\nexport type GetOrganisationNotesTransactionsQueryResult = Apollo.QueryResult<GetOrganisationNotesTransactionsQuery, GetOrganisationNotesTransactionsQueryVariables>;\nexport function refetchGetOrganisationNotesTransactionsQuery(variables: GetOrganisationNotesTransactionsQueryVariables) {\n      return { query: GetOrganisationNotesTransactionsDocument, variables: variables };\n    }\nexport const GetOrganisationSharetypeDataDocument: TypedDocumentNode<GetOrganisationSharetypeDataQuery, GetOrganisationSharetypeDataQueryVariables> = gql`\n  query getOrganisationSharetypeData($organisationId: UUID!) {\n  sharetypes(organisationId: $organisationId) {\n    id\n    name\n    symbol\n    voting\n    dividend\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationSharetypeDataQuery__\n *\n * To run a query within a React component, call `useGetOrganisationSharetypeDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationSharetypeDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationSharetypeDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetOrganisationSharetypeDataQuery(baseOptions: Apollo.QueryHookOptions<GetOrganisationSharetypeDataQuery, GetOrganisationSharetypeDataQueryVariables> & ({ variables: GetOrganisationSharetypeDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationSharetypeDataQuery, GetOrganisationSharetypeDataQueryVariables>(GetOrganisationSharetypeDataDocument, options);\n      }\nexport function useGetOrganisationSharetypeDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationSharetypeDataQuery, GetOrganisationSharetypeDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationSharetypeDataQuery, GetOrganisationSharetypeDataQueryVariables>(GetOrganisationSharetypeDataDocument, options);\n        }\nexport function useGetOrganisationSharetypeDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationSharetypeDataQuery, GetOrganisationSharetypeDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationSharetypeDataQuery, GetOrganisationSharetypeDataQueryVariables>(GetOrganisationSharetypeDataDocument, options);\n        }\nexport type GetOrganisationSharetypeDataQueryHookResult = ReturnType<typeof useGetOrganisationSharetypeDataQuery>;\nexport type GetOrganisationSharetypeDataLazyQueryHookResult = ReturnType<typeof useGetOrganisationSharetypeDataLazyQuery>;\nexport type GetOrganisationSharetypeDataSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationSharetypeDataSuspenseQuery>;\nexport type GetOrganisationSharetypeDataQueryResult = Apollo.QueryResult<GetOrganisationSharetypeDataQuery, GetOrganisationSharetypeDataQueryVariables>;\nexport function refetchGetOrganisationSharetypeDataQuery(variables: GetOrganisationSharetypeDataQueryVariables) {\n      return { query: GetOrganisationSharetypeDataDocument, variables: variables };\n    }\nexport const GetOrganisationSharetypesAndTotalsDocument: TypedDocumentNode<GetOrganisationSharetypesAndTotalsQuery, GetOrganisationSharetypesAndTotalsQueryVariables> = gql`\n  query getOrganisationSharetypesAndTotals($organisationId: UUID!) {\n  sharetypes(organisationId: $organisationId) {\n    id\n    name\n    symbol\n    voting\n    dividend\n    weight\n    totals {\n      totalShares\n      amountRaised\n      totalDue\n    }\n    authorisedShares\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationSharetypesAndTotalsQuery__\n *\n * To run a query within a React component, call `useGetOrganisationSharetypesAndTotalsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationSharetypesAndTotalsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationSharetypesAndTotalsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetOrganisationSharetypesAndTotalsQuery(baseOptions: Apollo.QueryHookOptions<GetOrganisationSharetypesAndTotalsQuery, GetOrganisationSharetypesAndTotalsQueryVariables> & ({ variables: GetOrganisationSharetypesAndTotalsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationSharetypesAndTotalsQuery, GetOrganisationSharetypesAndTotalsQueryVariables>(GetOrganisationSharetypesAndTotalsDocument, options);\n      }\nexport function useGetOrganisationSharetypesAndTotalsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationSharetypesAndTotalsQuery, GetOrganisationSharetypesAndTotalsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationSharetypesAndTotalsQuery, GetOrganisationSharetypesAndTotalsQueryVariables>(GetOrganisationSharetypesAndTotalsDocument, options);\n        }\nexport function useGetOrganisationSharetypesAndTotalsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationSharetypesAndTotalsQuery, GetOrganisationSharetypesAndTotalsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationSharetypesAndTotalsQuery, GetOrganisationSharetypesAndTotalsQueryVariables>(GetOrganisationSharetypesAndTotalsDocument, options);\n        }\nexport type GetOrganisationSharetypesAndTotalsQueryHookResult = ReturnType<typeof useGetOrganisationSharetypesAndTotalsQuery>;\nexport type GetOrganisationSharetypesAndTotalsLazyQueryHookResult = ReturnType<typeof useGetOrganisationSharetypesAndTotalsLazyQuery>;\nexport type GetOrganisationSharetypesAndTotalsSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationSharetypesAndTotalsSuspenseQuery>;\nexport type GetOrganisationSharetypesAndTotalsQueryResult = Apollo.QueryResult<GetOrganisationSharetypesAndTotalsQuery, GetOrganisationSharetypesAndTotalsQueryVariables>;\nexport function refetchGetOrganisationSharetypesAndTotalsQuery(variables: GetOrganisationSharetypesAndTotalsQueryVariables) {\n      return { query: GetOrganisationSharetypesAndTotalsDocument, variables: variables };\n    }\nexport const GetOrganisationOfficeholdersDataDocument: TypedDocumentNode<GetOrganisationOfficeholdersDataQuery, GetOrganisationOfficeholdersDataQueryVariables> = gql`\n  query getOrganisationOfficeholdersData($organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  officeholders(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    id\n    name\n    email\n    avatar\n    roles {\n      role\n      name\n    }\n    signer\n    signature\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationOfficeholdersDataQuery__\n *\n * To run a query within a React component, call `useGetOrganisationOfficeholdersDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationOfficeholdersDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationOfficeholdersDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetOrganisationOfficeholdersDataQuery(baseOptions: Apollo.QueryHookOptions<GetOrganisationOfficeholdersDataQuery, GetOrganisationOfficeholdersDataQueryVariables> & ({ variables: GetOrganisationOfficeholdersDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationOfficeholdersDataQuery, GetOrganisationOfficeholdersDataQueryVariables>(GetOrganisationOfficeholdersDataDocument, options);\n      }\nexport function useGetOrganisationOfficeholdersDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationOfficeholdersDataQuery, GetOrganisationOfficeholdersDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationOfficeholdersDataQuery, GetOrganisationOfficeholdersDataQueryVariables>(GetOrganisationOfficeholdersDataDocument, options);\n        }\nexport function useGetOrganisationOfficeholdersDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationOfficeholdersDataQuery, GetOrganisationOfficeholdersDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationOfficeholdersDataQuery, GetOrganisationOfficeholdersDataQueryVariables>(GetOrganisationOfficeholdersDataDocument, options);\n        }\nexport type GetOrganisationOfficeholdersDataQueryHookResult = ReturnType<typeof useGetOrganisationOfficeholdersDataQuery>;\nexport type GetOrganisationOfficeholdersDataLazyQueryHookResult = ReturnType<typeof useGetOrganisationOfficeholdersDataLazyQuery>;\nexport type GetOrganisationOfficeholdersDataSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationOfficeholdersDataSuspenseQuery>;\nexport type GetOrganisationOfficeholdersDataQueryResult = Apollo.QueryResult<GetOrganisationOfficeholdersDataQuery, GetOrganisationOfficeholdersDataQueryVariables>;\nexport function refetchGetOrganisationOfficeholdersDataQuery(variables: GetOrganisationOfficeholdersDataQueryVariables) {\n      return { query: GetOrganisationOfficeholdersDataDocument, variables: variables };\n    }\nexport const GetOrganisationOfficeholdersAndRolesDocument: TypedDocumentNode<GetOrganisationOfficeholdersAndRolesQuery, GetOrganisationOfficeholdersAndRolesQueryVariables> = gql`\n  query getOrganisationOfficeholdersAndRoles($organisationId: UUID!, $page: Int, $itemsPerPage: Int, $search: String, $excludeByIds: [UUID!]) {\n  officeholders(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    search: $search\n    excludeByIds: $excludeByIds\n  ) {\n    id\n    name\n    email\n    avatar\n    roles {\n      role\n      name\n    }\n    signer\n    signature\n  }\n  availableOfficeholderRoles {\n    role\n    name\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationOfficeholdersAndRolesQuery__\n *\n * To run a query within a React component, call `useGetOrganisationOfficeholdersAndRolesQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationOfficeholdersAndRolesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationOfficeholdersAndRolesQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      search: // value for 'search'\n *      excludeByIds: // value for 'excludeByIds'\n *   },\n * });\n */\nexport function useGetOrganisationOfficeholdersAndRolesQuery(baseOptions: Apollo.QueryHookOptions<GetOrganisationOfficeholdersAndRolesQuery, GetOrganisationOfficeholdersAndRolesQueryVariables> & ({ variables: GetOrganisationOfficeholdersAndRolesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationOfficeholdersAndRolesQuery, GetOrganisationOfficeholdersAndRolesQueryVariables>(GetOrganisationOfficeholdersAndRolesDocument, options);\n      }\nexport function useGetOrganisationOfficeholdersAndRolesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationOfficeholdersAndRolesQuery, GetOrganisationOfficeholdersAndRolesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationOfficeholdersAndRolesQuery, GetOrganisationOfficeholdersAndRolesQueryVariables>(GetOrganisationOfficeholdersAndRolesDocument, options);\n        }\nexport function useGetOrganisationOfficeholdersAndRolesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationOfficeholdersAndRolesQuery, GetOrganisationOfficeholdersAndRolesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationOfficeholdersAndRolesQuery, GetOrganisationOfficeholdersAndRolesQueryVariables>(GetOrganisationOfficeholdersAndRolesDocument, options);\n        }\nexport type GetOrganisationOfficeholdersAndRolesQueryHookResult = ReturnType<typeof useGetOrganisationOfficeholdersAndRolesQuery>;\nexport type GetOrganisationOfficeholdersAndRolesLazyQueryHookResult = ReturnType<typeof useGetOrganisationOfficeholdersAndRolesLazyQuery>;\nexport type GetOrganisationOfficeholdersAndRolesSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationOfficeholdersAndRolesSuspenseQuery>;\nexport type GetOrganisationOfficeholdersAndRolesQueryResult = Apollo.QueryResult<GetOrganisationOfficeholdersAndRolesQuery, GetOrganisationOfficeholdersAndRolesQueryVariables>;\nexport function refetchGetOrganisationOfficeholdersAndRolesQuery(variables: GetOrganisationOfficeholdersAndRolesQueryVariables) {\n      return { query: GetOrganisationOfficeholdersAndRolesDocument, variables: variables };\n    }\nexport const GetOrganisationOfficeholdersDataSimpleDocument: TypedDocumentNode<GetOrganisationOfficeholdersDataSimpleQuery, GetOrganisationOfficeholdersDataSimpleQueryVariables> = gql`\n  query getOrganisationOfficeholdersDataSimple($organisationId: UUID!) {\n  officeholders(organisationId: $organisationId) {\n    id\n    name\n    email\n    avatar\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationOfficeholdersDataSimpleQuery__\n *\n * To run a query within a React component, call `useGetOrganisationOfficeholdersDataSimpleQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationOfficeholdersDataSimpleQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationOfficeholdersDataSimpleQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetOrganisationOfficeholdersDataSimpleQuery(baseOptions: Apollo.QueryHookOptions<GetOrganisationOfficeholdersDataSimpleQuery, GetOrganisationOfficeholdersDataSimpleQueryVariables> & ({ variables: GetOrganisationOfficeholdersDataSimpleQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationOfficeholdersDataSimpleQuery, GetOrganisationOfficeholdersDataSimpleQueryVariables>(GetOrganisationOfficeholdersDataSimpleDocument, options);\n      }\nexport function useGetOrganisationOfficeholdersDataSimpleLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationOfficeholdersDataSimpleQuery, GetOrganisationOfficeholdersDataSimpleQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationOfficeholdersDataSimpleQuery, GetOrganisationOfficeholdersDataSimpleQueryVariables>(GetOrganisationOfficeholdersDataSimpleDocument, options);\n        }\nexport function useGetOrganisationOfficeholdersDataSimpleSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationOfficeholdersDataSimpleQuery, GetOrganisationOfficeholdersDataSimpleQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationOfficeholdersDataSimpleQuery, GetOrganisationOfficeholdersDataSimpleQueryVariables>(GetOrganisationOfficeholdersDataSimpleDocument, options);\n        }\nexport type GetOrganisationOfficeholdersDataSimpleQueryHookResult = ReturnType<typeof useGetOrganisationOfficeholdersDataSimpleQuery>;\nexport type GetOrganisationOfficeholdersDataSimpleLazyQueryHookResult = ReturnType<typeof useGetOrganisationOfficeholdersDataSimpleLazyQuery>;\nexport type GetOrganisationOfficeholdersDataSimpleSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationOfficeholdersDataSimpleSuspenseQuery>;\nexport type GetOrganisationOfficeholdersDataSimpleQueryResult = Apollo.QueryResult<GetOrganisationOfficeholdersDataSimpleQuery, GetOrganisationOfficeholdersDataSimpleQueryVariables>;\nexport function refetchGetOrganisationOfficeholdersDataSimpleQuery(variables: GetOrganisationOfficeholdersDataSimpleQueryVariables) {\n      return { query: GetOrganisationOfficeholdersDataSimpleDocument, variables: variables };\n    }\nexport const GetOrganisationAvailableOfficeholderRolesDocument: TypedDocumentNode<GetOrganisationAvailableOfficeholderRolesQuery, GetOrganisationAvailableOfficeholderRolesQueryVariables> = gql`\n  query getOrganisationAvailableOfficeholderRoles {\n  availableOfficeholderRoles {\n    role\n    name\n  }\n  availableOrganisationRoles {\n    roles {\n      role\n      description\n    }\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationAvailableOfficeholderRolesQuery__\n *\n * To run a query within a React component, call `useGetOrganisationAvailableOfficeholderRolesQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationAvailableOfficeholderRolesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationAvailableOfficeholderRolesQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useGetOrganisationAvailableOfficeholderRolesQuery(baseOptions?: Apollo.QueryHookOptions<GetOrganisationAvailableOfficeholderRolesQuery, GetOrganisationAvailableOfficeholderRolesQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationAvailableOfficeholderRolesQuery, GetOrganisationAvailableOfficeholderRolesQueryVariables>(GetOrganisationAvailableOfficeholderRolesDocument, options);\n      }\nexport function useGetOrganisationAvailableOfficeholderRolesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationAvailableOfficeholderRolesQuery, GetOrganisationAvailableOfficeholderRolesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationAvailableOfficeholderRolesQuery, GetOrganisationAvailableOfficeholderRolesQueryVariables>(GetOrganisationAvailableOfficeholderRolesDocument, options);\n        }\nexport function useGetOrganisationAvailableOfficeholderRolesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationAvailableOfficeholderRolesQuery, GetOrganisationAvailableOfficeholderRolesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationAvailableOfficeholderRolesQuery, GetOrganisationAvailableOfficeholderRolesQueryVariables>(GetOrganisationAvailableOfficeholderRolesDocument, options);\n        }\nexport type GetOrganisationAvailableOfficeholderRolesQueryHookResult = ReturnType<typeof useGetOrganisationAvailableOfficeholderRolesQuery>;\nexport type GetOrganisationAvailableOfficeholderRolesLazyQueryHookResult = ReturnType<typeof useGetOrganisationAvailableOfficeholderRolesLazyQuery>;\nexport type GetOrganisationAvailableOfficeholderRolesSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationAvailableOfficeholderRolesSuspenseQuery>;\nexport type GetOrganisationAvailableOfficeholderRolesQueryResult = Apollo.QueryResult<GetOrganisationAvailableOfficeholderRolesQuery, GetOrganisationAvailableOfficeholderRolesQueryVariables>;\nexport function refetchGetOrganisationAvailableOfficeholderRolesQuery(variables?: GetOrganisationAvailableOfficeholderRolesQueryVariables) {\n      return { query: GetOrganisationAvailableOfficeholderRolesDocument, variables: variables };\n    }\nexport const CreateOrganisationSignupDocument: TypedDocumentNode<CreateOrganisationSignupMutation, CreateOrganisationSignupMutationVariables> = gql`\n  mutation createOrganisationSignup($name: CleanString!, $country: CleanString!, $creationIntents: [CleanString!], $companyType: CleanString, $fundingPhase: CleanString, $companySize: CleanString, $creatorRole: CleanString, $experienceLevel: CleanString, $reasonForOnboarding: CleanString, $sourceOfReferral: CleanString, $interestedIn409a: Boolean, $mobileNumber: CleanString, $copilots: [InvitedUserInput]) {\n  createOrganisationSignup(\n    name: $name\n    country: $country\n    creationIntents: $creationIntents\n    companyType: $companyType\n    fundingPhase: $fundingPhase\n    companySize: $companySize\n    creatorRole: $creatorRole\n    experienceLevel: $experienceLevel\n    reasonForOnboarding: $reasonForOnboarding\n    sourceOfReferral: $sourceOfReferral\n    interestedIn409a: $interestedIn409a\n    mobileNumber: $mobileNumber\n    copilots: $copilots\n  ) {\n    organisation {\n      id\n    }\n  }\n}\n    `;\nexport type CreateOrganisationSignupMutationFn = Apollo.MutationFunction<CreateOrganisationSignupMutation, CreateOrganisationSignupMutationVariables>;\n\n/**\n * __useCreateOrganisationSignupMutation__\n *\n * To run a mutation, you first call `useCreateOrganisationSignupMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateOrganisationSignupMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createOrganisationSignupMutation, { data, loading, error }] = useCreateOrganisationSignupMutation({\n *   variables: {\n *      name: // value for 'name'\n *      country: // value for 'country'\n *      creationIntents: // value for 'creationIntents'\n *      companyType: // value for 'companyType'\n *      fundingPhase: // value for 'fundingPhase'\n *      companySize: // value for 'companySize'\n *      creatorRole: // value for 'creatorRole'\n *      experienceLevel: // value for 'experienceLevel'\n *      reasonForOnboarding: // value for 'reasonForOnboarding'\n *      sourceOfReferral: // value for 'sourceOfReferral'\n *      interestedIn409a: // value for 'interestedIn409a'\n *      mobileNumber: // value for 'mobileNumber'\n *      copilots: // value for 'copilots'\n *   },\n * });\n */\nexport function useCreateOrganisationSignupMutation(baseOptions?: Apollo.MutationHookOptions<CreateOrganisationSignupMutation, CreateOrganisationSignupMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateOrganisationSignupMutation, CreateOrganisationSignupMutationVariables>(CreateOrganisationSignupDocument, options);\n      }\nexport type CreateOrganisationSignupMutationHookResult = ReturnType<typeof useCreateOrganisationSignupMutation>;\nexport type CreateOrganisationSignupMutationResult = Apollo.MutationResult<CreateOrganisationSignupMutation>;\nexport type CreateOrganisationSignupMutationOptions = Apollo.BaseMutationOptions<CreateOrganisationSignupMutation, CreateOrganisationSignupMutationVariables>;\nexport const AddNewOfficeholderDocument: TypedDocumentNode<AddNewOfficeholderMutation, AddNewOfficeholderMutationVariables> = gql`\n  mutation addNewOfficeholder($organisationId: UUID!, $officeholder: OfficeholderInput!) {\n  addOfficeholder(\n    addOfficeholderData: {organisationId: $organisationId, officeholder: $officeholder}\n  ) {\n    officeholder {\n      id\n    }\n  }\n}\n    `;\nexport type AddNewOfficeholderMutationFn = Apollo.MutationFunction<AddNewOfficeholderMutation, AddNewOfficeholderMutationVariables>;\n\n/**\n * __useAddNewOfficeholderMutation__\n *\n * To run a mutation, you first call `useAddNewOfficeholderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddNewOfficeholderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addNewOfficeholderMutation, { data, loading, error }] = useAddNewOfficeholderMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      officeholder: // value for 'officeholder'\n *   },\n * });\n */\nexport function useAddNewOfficeholderMutation(baseOptions?: Apollo.MutationHookOptions<AddNewOfficeholderMutation, AddNewOfficeholderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddNewOfficeholderMutation, AddNewOfficeholderMutationVariables>(AddNewOfficeholderDocument, options);\n      }\nexport type AddNewOfficeholderMutationHookResult = ReturnType<typeof useAddNewOfficeholderMutation>;\nexport type AddNewOfficeholderMutationResult = Apollo.MutationResult<AddNewOfficeholderMutation>;\nexport type AddNewOfficeholderMutationOptions = Apollo.BaseMutationOptions<AddNewOfficeholderMutation, AddNewOfficeholderMutationVariables>;\nexport const AddOrUpdateCompanySignersDocument: TypedDocumentNode<AddOrUpdateCompanySignersMutation, AddOrUpdateCompanySignersMutationVariables> = gql`\n  mutation addOrUpdateCompanySigners($organisationId: OrganisationCakeType!, $signers: [AddOrUpdateCompanySignersInput!]!) {\n  addOrUpdateCompanySigners(organisation: $organisationId, signers: $signers)\n}\n    `;\nexport type AddOrUpdateCompanySignersMutationFn = Apollo.MutationFunction<AddOrUpdateCompanySignersMutation, AddOrUpdateCompanySignersMutationVariables>;\n\n/**\n * __useAddOrUpdateCompanySignersMutation__\n *\n * To run a mutation, you first call `useAddOrUpdateCompanySignersMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddOrUpdateCompanySignersMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addOrUpdateCompanySignersMutation, { data, loading, error }] = useAddOrUpdateCompanySignersMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      signers: // value for 'signers'\n *   },\n * });\n */\nexport function useAddOrUpdateCompanySignersMutation(baseOptions?: Apollo.MutationHookOptions<AddOrUpdateCompanySignersMutation, AddOrUpdateCompanySignersMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddOrUpdateCompanySignersMutation, AddOrUpdateCompanySignersMutationVariables>(AddOrUpdateCompanySignersDocument, options);\n      }\nexport type AddOrUpdateCompanySignersMutationHookResult = ReturnType<typeof useAddOrUpdateCompanySignersMutation>;\nexport type AddOrUpdateCompanySignersMutationResult = Apollo.MutationResult<AddOrUpdateCompanySignersMutation>;\nexport type AddOrUpdateCompanySignersMutationOptions = Apollo.BaseMutationOptions<AddOrUpdateCompanySignersMutation, AddOrUpdateCompanySignersMutationVariables>;\nexport const AddOrRenewSupportRoleDocument: TypedDocumentNode<AddOrRenewSupportRoleMutation, AddOrRenewSupportRoleMutationVariables> = gql`\n  mutation addOrRenewSupportRole($organisationId: UUID!) {\n  addOrRenewSupportRole(organisationId: $organisationId)\n}\n    `;\nexport type AddOrRenewSupportRoleMutationFn = Apollo.MutationFunction<AddOrRenewSupportRoleMutation, AddOrRenewSupportRoleMutationVariables>;\n\n/**\n * __useAddOrRenewSupportRoleMutation__\n *\n * To run a mutation, you first call `useAddOrRenewSupportRoleMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddOrRenewSupportRoleMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addOrRenewSupportRoleMutation, { data, loading, error }] = useAddOrRenewSupportRoleMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useAddOrRenewSupportRoleMutation(baseOptions?: Apollo.MutationHookOptions<AddOrRenewSupportRoleMutation, AddOrRenewSupportRoleMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddOrRenewSupportRoleMutation, AddOrRenewSupportRoleMutationVariables>(AddOrRenewSupportRoleDocument, options);\n      }\nexport type AddOrRenewSupportRoleMutationHookResult = ReturnType<typeof useAddOrRenewSupportRoleMutation>;\nexport type AddOrRenewSupportRoleMutationResult = Apollo.MutationResult<AddOrRenewSupportRoleMutation>;\nexport type AddOrRenewSupportRoleMutationOptions = Apollo.BaseMutationOptions<AddOrRenewSupportRoleMutation, AddOrRenewSupportRoleMutationVariables>;\nexport const UpdateOrganisationUploadInProgressDocument: TypedDocumentNode<UpdateOrganisationUploadInProgressMutation, UpdateOrganisationUploadInProgressMutationVariables> = gql`\n  mutation updateOrganisationUploadInProgress($organisationId: OrganisationCakeType!, $uploadInProgress: Boolean!) {\n  updateOrganisationUploadInProgress(\n    organisation: $organisationId\n    uploadInProgress: $uploadInProgress\n  )\n}\n    `;\nexport type UpdateOrganisationUploadInProgressMutationFn = Apollo.MutationFunction<UpdateOrganisationUploadInProgressMutation, UpdateOrganisationUploadInProgressMutationVariables>;\n\n/**\n * __useUpdateOrganisationUploadInProgressMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationUploadInProgressMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationUploadInProgressMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationUploadInProgressMutation, { data, loading, error }] = useUpdateOrganisationUploadInProgressMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      uploadInProgress: // value for 'uploadInProgress'\n *   },\n * });\n */\nexport function useUpdateOrganisationUploadInProgressMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationUploadInProgressMutation, UpdateOrganisationUploadInProgressMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationUploadInProgressMutation, UpdateOrganisationUploadInProgressMutationVariables>(UpdateOrganisationUploadInProgressDocument, options);\n      }\nexport type UpdateOrganisationUploadInProgressMutationHookResult = ReturnType<typeof useUpdateOrganisationUploadInProgressMutation>;\nexport type UpdateOrganisationUploadInProgressMutationResult = Apollo.MutationResult<UpdateOrganisationUploadInProgressMutation>;\nexport type UpdateOrganisationUploadInProgressMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationUploadInProgressMutation, UpdateOrganisationUploadInProgressMutationVariables>;\nexport const UpdateOrganisationHideUpcomingInvoiceDocument: TypedDocumentNode<UpdateOrganisationHideUpcomingInvoiceMutation, UpdateOrganisationHideUpcomingInvoiceMutationVariables> = gql`\n  mutation updateOrganisationHideUpcomingInvoice($organisationId: OrganisationCakeType!, $hideUpcomingInvoice: Boolean!) {\n  updateOrganisationHideUpcomingInvoice(\n    organisation: $organisationId\n    hideUpcomingInvoice: $hideUpcomingInvoice\n  )\n}\n    `;\nexport type UpdateOrganisationHideUpcomingInvoiceMutationFn = Apollo.MutationFunction<UpdateOrganisationHideUpcomingInvoiceMutation, UpdateOrganisationHideUpcomingInvoiceMutationVariables>;\n\n/**\n * __useUpdateOrganisationHideUpcomingInvoiceMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationHideUpcomingInvoiceMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationHideUpcomingInvoiceMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationHideUpcomingInvoiceMutation, { data, loading, error }] = useUpdateOrganisationHideUpcomingInvoiceMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      hideUpcomingInvoice: // value for 'hideUpcomingInvoice'\n *   },\n * });\n */\nexport function useUpdateOrganisationHideUpcomingInvoiceMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationHideUpcomingInvoiceMutation, UpdateOrganisationHideUpcomingInvoiceMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationHideUpcomingInvoiceMutation, UpdateOrganisationHideUpcomingInvoiceMutationVariables>(UpdateOrganisationHideUpcomingInvoiceDocument, options);\n      }\nexport type UpdateOrganisationHideUpcomingInvoiceMutationHookResult = ReturnType<typeof useUpdateOrganisationHideUpcomingInvoiceMutation>;\nexport type UpdateOrganisationHideUpcomingInvoiceMutationResult = Apollo.MutationResult<UpdateOrganisationHideUpcomingInvoiceMutation>;\nexport type UpdateOrganisationHideUpcomingInvoiceMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationHideUpcomingInvoiceMutation, UpdateOrganisationHideUpcomingInvoiceMutationVariables>;\nexport const UpdateOrganisationBasicDocument: TypedDocumentNode<UpdateOrganisationBasicMutation, UpdateOrganisationBasicMutationVariables> = gql`\n  mutation updateOrganisationBasic($organisationId: OrganisationCakeType!, $name: CleanString!, $currency: CleanString, $companyType: CleanString) {\n  updateOrganisationBasic(\n    name: $name\n    currency: $currency\n    organisation: $organisationId\n    companyType: $companyType\n  ) {\n    organisation {\n      id\n    }\n  }\n}\n    `;\nexport type UpdateOrganisationBasicMutationFn = Apollo.MutationFunction<UpdateOrganisationBasicMutation, UpdateOrganisationBasicMutationVariables>;\n\n/**\n * __useUpdateOrganisationBasicMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationBasicMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationBasicMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationBasicMutation, { data, loading, error }] = useUpdateOrganisationBasicMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      name: // value for 'name'\n *      currency: // value for 'currency'\n *      companyType: // value for 'companyType'\n *   },\n * });\n */\nexport function useUpdateOrganisationBasicMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationBasicMutation, UpdateOrganisationBasicMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationBasicMutation, UpdateOrganisationBasicMutationVariables>(UpdateOrganisationBasicDocument, options);\n      }\nexport type UpdateOrganisationBasicMutationHookResult = ReturnType<typeof useUpdateOrganisationBasicMutation>;\nexport type UpdateOrganisationBasicMutationResult = Apollo.MutationResult<UpdateOrganisationBasicMutation>;\nexport type UpdateOrganisationBasicMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationBasicMutation, UpdateOrganisationBasicMutationVariables>;\nexport const UpdateOrganisationAuDocument: TypedDocumentNode<UpdateOrganisationAuMutation, UpdateOrganisationAuMutationVariables> = gql`\n  mutation updateOrganisationAu($organisationId: OrganisationCakeType!, $name: CleanString!, $currency: CleanString, $companyType: CleanString, $shareCertificateType: CleanString, $auCompanyDetails: AuCompanyDetailsInput!) {\n  updateOrganisationAu(\n    name: $name\n    currency: $currency\n    organisation: $organisationId\n    companyType: $companyType\n    shareCertificateType: $shareCertificateType\n    auCompanyDetails: $auCompanyDetails\n  ) {\n    organisation {\n      id\n      name\n    }\n  }\n}\n    `;\nexport type UpdateOrganisationAuMutationFn = Apollo.MutationFunction<UpdateOrganisationAuMutation, UpdateOrganisationAuMutationVariables>;\n\n/**\n * __useUpdateOrganisationAuMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationAuMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationAuMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationAuMutation, { data, loading, error }] = useUpdateOrganisationAuMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      name: // value for 'name'\n *      currency: // value for 'currency'\n *      companyType: // value for 'companyType'\n *      shareCertificateType: // value for 'shareCertificateType'\n *      auCompanyDetails: // value for 'auCompanyDetails'\n *   },\n * });\n */\nexport function useUpdateOrganisationAuMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationAuMutation, UpdateOrganisationAuMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationAuMutation, UpdateOrganisationAuMutationVariables>(UpdateOrganisationAuDocument, options);\n      }\nexport type UpdateOrganisationAuMutationHookResult = ReturnType<typeof useUpdateOrganisationAuMutation>;\nexport type UpdateOrganisationAuMutationResult = Apollo.MutationResult<UpdateOrganisationAuMutation>;\nexport type UpdateOrganisationAuMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationAuMutation, UpdateOrganisationAuMutationVariables>;\nexport const UpdateOrganisationSgDocument: TypedDocumentNode<UpdateOrganisationSgMutation, UpdateOrganisationSgMutationVariables> = gql`\n  mutation updateOrganisationSg($organisationId: OrganisationCakeType!, $name: CleanString!, $currency: CleanString, $companyType: CleanString, $shareCertificateType: CleanString, $sgCompanyDetails: SgCompanyDetailsInput!) {\n  updateOrganisationSg(\n    name: $name\n    currency: $currency\n    organisation: $organisationId\n    companyType: $companyType\n    shareCertificateType: $shareCertificateType\n    sgCompanyDetails: $sgCompanyDetails\n  ) {\n    organisation {\n      id\n    }\n  }\n}\n    `;\nexport type UpdateOrganisationSgMutationFn = Apollo.MutationFunction<UpdateOrganisationSgMutation, UpdateOrganisationSgMutationVariables>;\n\n/**\n * __useUpdateOrganisationSgMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationSgMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationSgMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationSgMutation, { data, loading, error }] = useUpdateOrganisationSgMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      name: // value for 'name'\n *      currency: // value for 'currency'\n *      companyType: // value for 'companyType'\n *      shareCertificateType: // value for 'shareCertificateType'\n *      sgCompanyDetails: // value for 'sgCompanyDetails'\n *   },\n * });\n */\nexport function useUpdateOrganisationSgMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationSgMutation, UpdateOrganisationSgMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationSgMutation, UpdateOrganisationSgMutationVariables>(UpdateOrganisationSgDocument, options);\n      }\nexport type UpdateOrganisationSgMutationHookResult = ReturnType<typeof useUpdateOrganisationSgMutation>;\nexport type UpdateOrganisationSgMutationResult = Apollo.MutationResult<UpdateOrganisationSgMutation>;\nexport type UpdateOrganisationSgMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationSgMutation, UpdateOrganisationSgMutationVariables>;\nexport const UpdateOrganisationUsDocument: TypedDocumentNode<UpdateOrganisationUsMutation, UpdateOrganisationUsMutationVariables> = gql`\n  mutation updateOrganisationUs($organisationId: OrganisationCakeType!, $name: CleanString!, $currency: CleanString, $companyType: CleanString, $shareCertificateType: CleanString, $usCompanyDetails: UsCompanyDetailsInput!) {\n  updateOrganisationUs(\n    name: $name\n    currency: $currency\n    organisation: $organisationId\n    companyType: $companyType\n    shareCertificateType: $shareCertificateType\n    usCompanyDetails: $usCompanyDetails\n  ) {\n    organisation {\n      id\n    }\n  }\n}\n    `;\nexport type UpdateOrganisationUsMutationFn = Apollo.MutationFunction<UpdateOrganisationUsMutation, UpdateOrganisationUsMutationVariables>;\n\n/**\n * __useUpdateOrganisationUsMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationUsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationUsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationUsMutation, { data, loading, error }] = useUpdateOrganisationUsMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      name: // value for 'name'\n *      currency: // value for 'currency'\n *      companyType: // value for 'companyType'\n *      shareCertificateType: // value for 'shareCertificateType'\n *      usCompanyDetails: // value for 'usCompanyDetails'\n *   },\n * });\n */\nexport function useUpdateOrganisationUsMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationUsMutation, UpdateOrganisationUsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationUsMutation, UpdateOrganisationUsMutationVariables>(UpdateOrganisationUsDocument, options);\n      }\nexport type UpdateOrganisationUsMutationHookResult = ReturnType<typeof useUpdateOrganisationUsMutation>;\nexport type UpdateOrganisationUsMutationResult = Apollo.MutationResult<UpdateOrganisationUsMutation>;\nexport type UpdateOrganisationUsMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationUsMutation, UpdateOrganisationUsMutationVariables>;\nexport const UpdateOrganisationGbDocument: TypedDocumentNode<UpdateOrganisationGbMutation, UpdateOrganisationGbMutationVariables> = gql`\n  mutation updateOrganisationGb($organisationId: OrganisationCakeType!, $name: CleanString!, $currency: CleanString, $companyType: CleanString, $shareCertificateType: CleanString, $gbCompanyDetails: GbCompanyDetailsInput!) {\n  updateOrganisationGb(\n    name: $name\n    currency: $currency\n    organisation: $organisationId\n    companyType: $companyType\n    shareCertificateType: $shareCertificateType\n    gbCompanyDetails: $gbCompanyDetails\n  ) {\n    organisation {\n      id\n    }\n  }\n}\n    `;\nexport type UpdateOrganisationGbMutationFn = Apollo.MutationFunction<UpdateOrganisationGbMutation, UpdateOrganisationGbMutationVariables>;\n\n/**\n * __useUpdateOrganisationGbMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationGbMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationGbMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationGbMutation, { data, loading, error }] = useUpdateOrganisationGbMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      name: // value for 'name'\n *      currency: // value for 'currency'\n *      companyType: // value for 'companyType'\n *      shareCertificateType: // value for 'shareCertificateType'\n *      gbCompanyDetails: // value for 'gbCompanyDetails'\n *   },\n * });\n */\nexport function useUpdateOrganisationGbMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationGbMutation, UpdateOrganisationGbMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationGbMutation, UpdateOrganisationGbMutationVariables>(UpdateOrganisationGbDocument, options);\n      }\nexport type UpdateOrganisationGbMutationHookResult = ReturnType<typeof useUpdateOrganisationGbMutation>;\nexport type UpdateOrganisationGbMutationResult = Apollo.MutationResult<UpdateOrganisationGbMutation>;\nexport type UpdateOrganisationGbMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationGbMutation, UpdateOrganisationGbMutationVariables>;\nexport const UpdateOrganisationNzDocument: TypedDocumentNode<UpdateOrganisationNzMutation, UpdateOrganisationNzMutationVariables> = gql`\n  mutation updateOrganisationNz($organisationId: OrganisationCakeType!, $name: CleanString!, $currency: CleanString, $companyType: CleanString, $nzCompanyDetails: NzCompanyDetailsInput!) {\n  updateOrganisationNz(\n    name: $name\n    currency: $currency\n    organisation: $organisationId\n    companyType: $companyType\n    nzCompanyDetails: $nzCompanyDetails\n  ) {\n    organisation {\n      id\n    }\n  }\n}\n    `;\nexport type UpdateOrganisationNzMutationFn = Apollo.MutationFunction<UpdateOrganisationNzMutation, UpdateOrganisationNzMutationVariables>;\n\n/**\n * __useUpdateOrganisationNzMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationNzMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationNzMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationNzMutation, { data, loading, error }] = useUpdateOrganisationNzMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      name: // value for 'name'\n *      currency: // value for 'currency'\n *      companyType: // value for 'companyType'\n *      nzCompanyDetails: // value for 'nzCompanyDetails'\n *   },\n * });\n */\nexport function useUpdateOrganisationNzMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationNzMutation, UpdateOrganisationNzMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationNzMutation, UpdateOrganisationNzMutationVariables>(UpdateOrganisationNzDocument, options);\n      }\nexport type UpdateOrganisationNzMutationHookResult = ReturnType<typeof useUpdateOrganisationNzMutation>;\nexport type UpdateOrganisationNzMutationResult = Apollo.MutationResult<UpdateOrganisationNzMutation>;\nexport type UpdateOrganisationNzMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationNzMutation, UpdateOrganisationNzMutationVariables>;\nexport const UpdateOrganisationInDocument: TypedDocumentNode<UpdateOrganisationInMutation, UpdateOrganisationInMutationVariables> = gql`\n  mutation updateOrganisationIn($organisationId: OrganisationCakeType!, $name: CleanString!, $currency: CleanString, $inCompanyDetails: InCompanyDetailsInput!, $shareCertificateType: CleanString, $companyType: CleanString) {\n  updateOrganisationIn(\n    name: $name\n    currency: $currency\n    organisation: $organisationId\n    inCompanyDetails: $inCompanyDetails\n    shareCertificateType: $shareCertificateType\n    companyType: $companyType\n  ) {\n    organisation {\n      id\n    }\n  }\n}\n    `;\nexport type UpdateOrganisationInMutationFn = Apollo.MutationFunction<UpdateOrganisationInMutation, UpdateOrganisationInMutationVariables>;\n\n/**\n * __useUpdateOrganisationInMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationInMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationInMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationInMutation, { data, loading, error }] = useUpdateOrganisationInMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      name: // value for 'name'\n *      currency: // value for 'currency'\n *      inCompanyDetails: // value for 'inCompanyDetails'\n *      shareCertificateType: // value for 'shareCertificateType'\n *      companyType: // value for 'companyType'\n *   },\n * });\n */\nexport function useUpdateOrganisationInMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationInMutation, UpdateOrganisationInMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationInMutation, UpdateOrganisationInMutationVariables>(UpdateOrganisationInDocument, options);\n      }\nexport type UpdateOrganisationInMutationHookResult = ReturnType<typeof useUpdateOrganisationInMutation>;\nexport type UpdateOrganisationInMutationResult = Apollo.MutationResult<UpdateOrganisationInMutation>;\nexport type UpdateOrganisationInMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationInMutation, UpdateOrganisationInMutationVariables>;\nexport const UpdateOrganisationCaDocument: TypedDocumentNode<UpdateOrganisationCaMutation, UpdateOrganisationCaMutationVariables> = gql`\n  mutation updateOrganisationCa($organisationId: OrganisationCakeType!, $name: CleanString!, $currency: CleanString, $companyType: CleanString, $shareCertificateType: CleanString, $caCompanyDetails: CaCompanyDetailsInput!) {\n  updateOrganisationCa(\n    name: $name\n    currency: $currency\n    organisation: $organisationId\n    companyType: $companyType\n    shareCertificateType: $shareCertificateType\n    caCompanyDetails: $caCompanyDetails\n  ) {\n    organisation {\n      id\n    }\n  }\n}\n    `;\nexport type UpdateOrganisationCaMutationFn = Apollo.MutationFunction<UpdateOrganisationCaMutation, UpdateOrganisationCaMutationVariables>;\n\n/**\n * __useUpdateOrganisationCaMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationCaMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationCaMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationCaMutation, { data, loading, error }] = useUpdateOrganisationCaMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      name: // value for 'name'\n *      currency: // value for 'currency'\n *      companyType: // value for 'companyType'\n *      shareCertificateType: // value for 'shareCertificateType'\n *      caCompanyDetails: // value for 'caCompanyDetails'\n *   },\n * });\n */\nexport function useUpdateOrganisationCaMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationCaMutation, UpdateOrganisationCaMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationCaMutation, UpdateOrganisationCaMutationVariables>(UpdateOrganisationCaDocument, options);\n      }\nexport type UpdateOrganisationCaMutationHookResult = ReturnType<typeof useUpdateOrganisationCaMutation>;\nexport type UpdateOrganisationCaMutationResult = Apollo.MutationResult<UpdateOrganisationCaMutation>;\nexport type UpdateOrganisationCaMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationCaMutation, UpdateOrganisationCaMutationVariables>;\nexport const UpdateOrganisationEeDocument: TypedDocumentNode<UpdateOrganisationEeMutation, UpdateOrganisationEeMutationVariables> = gql`\n  mutation updateOrganisationEe($organisationId: OrganisationCakeType!, $name: CleanString!, $currency: CleanString, $companyType: CleanString, $eeCompanyDetails: EeCompanyDetailsInput!) {\n  updateOrganisationEe(\n    name: $name\n    currency: $currency\n    organisation: $organisationId\n    companyType: $companyType\n    eeCompanyDetails: $eeCompanyDetails\n  ) {\n    organisation {\n      id\n    }\n  }\n}\n    `;\nexport type UpdateOrganisationEeMutationFn = Apollo.MutationFunction<UpdateOrganisationEeMutation, UpdateOrganisationEeMutationVariables>;\n\n/**\n * __useUpdateOrganisationEeMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationEeMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationEeMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationEeMutation, { data, loading, error }] = useUpdateOrganisationEeMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      name: // value for 'name'\n *      currency: // value for 'currency'\n *      companyType: // value for 'companyType'\n *      eeCompanyDetails: // value for 'eeCompanyDetails'\n *   },\n * });\n */\nexport function useUpdateOrganisationEeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationEeMutation, UpdateOrganisationEeMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationEeMutation, UpdateOrganisationEeMutationVariables>(UpdateOrganisationEeDocument, options);\n      }\nexport type UpdateOrganisationEeMutationHookResult = ReturnType<typeof useUpdateOrganisationEeMutation>;\nexport type UpdateOrganisationEeMutationResult = Apollo.MutationResult<UpdateOrganisationEeMutation>;\nexport type UpdateOrganisationEeMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationEeMutation, UpdateOrganisationEeMutationVariables>;\nexport const UpdateTransactionUnpaidAmountDocument: TypedDocumentNode<UpdateTransactionUnpaidAmountMutation, UpdateTransactionUnpaidAmountMutationVariables> = gql`\n  mutation updateTransactionUnpaidAmount($transaction: ShareholdingTransactionCakeType!, $unpaidAmount: CakeDecimal!) {\n  updateTransactionUnpaidAmount(tr: $transaction, unpaidAmount: $unpaidAmount) {\n    ok\n  }\n}\n    `;\nexport type UpdateTransactionUnpaidAmountMutationFn = Apollo.MutationFunction<UpdateTransactionUnpaidAmountMutation, UpdateTransactionUnpaidAmountMutationVariables>;\n\n/**\n * __useUpdateTransactionUnpaidAmountMutation__\n *\n * To run a mutation, you first call `useUpdateTransactionUnpaidAmountMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateTransactionUnpaidAmountMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateTransactionUnpaidAmountMutation, { data, loading, error }] = useUpdateTransactionUnpaidAmountMutation({\n *   variables: {\n *      transaction: // value for 'transaction'\n *      unpaidAmount: // value for 'unpaidAmount'\n *   },\n * });\n */\nexport function useUpdateTransactionUnpaidAmountMutation(baseOptions?: Apollo.MutationHookOptions<UpdateTransactionUnpaidAmountMutation, UpdateTransactionUnpaidAmountMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateTransactionUnpaidAmountMutation, UpdateTransactionUnpaidAmountMutationVariables>(UpdateTransactionUnpaidAmountDocument, options);\n      }\nexport type UpdateTransactionUnpaidAmountMutationHookResult = ReturnType<typeof useUpdateTransactionUnpaidAmountMutation>;\nexport type UpdateTransactionUnpaidAmountMutationResult = Apollo.MutationResult<UpdateTransactionUnpaidAmountMutation>;\nexport type UpdateTransactionUnpaidAmountMutationOptions = Apollo.BaseMutationOptions<UpdateTransactionUnpaidAmountMutation, UpdateTransactionUnpaidAmountMutationVariables>;\nexport const UpdateOrganisationFundingPhaseDocument: TypedDocumentNode<UpdateOrganisationFundingPhaseMutation, UpdateOrganisationFundingPhaseMutationVariables> = gql`\n  mutation updateOrganisationFundingPhase($organisationId: OrganisationCakeType!, $fundingPhase: CleanString!) {\n  updateOrganisationFundingPhase(\n    fundingPhase: $fundingPhase\n    organisation: $organisationId\n  )\n}\n    `;\nexport type UpdateOrganisationFundingPhaseMutationFn = Apollo.MutationFunction<UpdateOrganisationFundingPhaseMutation, UpdateOrganisationFundingPhaseMutationVariables>;\n\n/**\n * __useUpdateOrganisationFundingPhaseMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationFundingPhaseMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationFundingPhaseMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationFundingPhaseMutation, { data, loading, error }] = useUpdateOrganisationFundingPhaseMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      fundingPhase: // value for 'fundingPhase'\n *   },\n * });\n */\nexport function useUpdateOrganisationFundingPhaseMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationFundingPhaseMutation, UpdateOrganisationFundingPhaseMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationFundingPhaseMutation, UpdateOrganisationFundingPhaseMutationVariables>(UpdateOrganisationFundingPhaseDocument, options);\n      }\nexport type UpdateOrganisationFundingPhaseMutationHookResult = ReturnType<typeof useUpdateOrganisationFundingPhaseMutation>;\nexport type UpdateOrganisationFundingPhaseMutationResult = Apollo.MutationResult<UpdateOrganisationFundingPhaseMutation>;\nexport type UpdateOrganisationFundingPhaseMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationFundingPhaseMutation, UpdateOrganisationFundingPhaseMutationVariables>;\nexport const UpdateOfficeholderDocument: TypedDocumentNode<UpdateOfficeholderMutation, UpdateOfficeholderMutationVariables> = gql`\n  mutation updateOfficeholder($updateOfficeholderData: UpdateOfficeholderData!) {\n  updateOfficeholder(updateOfficeholderData: $updateOfficeholderData) {\n    officeholder {\n      id\n      name\n      email\n      roles {\n        role\n        name\n      }\n      signer\n    }\n  }\n}\n    `;\nexport type UpdateOfficeholderMutationFn = Apollo.MutationFunction<UpdateOfficeholderMutation, UpdateOfficeholderMutationVariables>;\n\n/**\n * __useUpdateOfficeholderMutation__\n *\n * To run a mutation, you first call `useUpdateOfficeholderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOfficeholderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOfficeholderMutation, { data, loading, error }] = useUpdateOfficeholderMutation({\n *   variables: {\n *      updateOfficeholderData: // value for 'updateOfficeholderData'\n *   },\n * });\n */\nexport function useUpdateOfficeholderMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOfficeholderMutation, UpdateOfficeholderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOfficeholderMutation, UpdateOfficeholderMutationVariables>(UpdateOfficeholderDocument, options);\n      }\nexport type UpdateOfficeholderMutationHookResult = ReturnType<typeof useUpdateOfficeholderMutation>;\nexport type UpdateOfficeholderMutationResult = Apollo.MutationResult<UpdateOfficeholderMutation>;\nexport type UpdateOfficeholderMutationOptions = Apollo.BaseMutationOptions<UpdateOfficeholderMutation, UpdateOfficeholderMutationVariables>;\nexport const UpdateSharetypeDocument: TypedDocumentNode<UpdateSharetypeMutation, UpdateSharetypeMutationVariables> = gql`\n  mutation updateSharetype($updateSharetypeData: UpdateSharetypeData!) {\n  updateSharetype(updateSharetypeData: $updateSharetypeData) {\n    sharetype {\n      id\n      name\n      symbol\n      voting\n      dividend\n      authorisedShares\n    }\n  }\n}\n    `;\nexport type UpdateSharetypeMutationFn = Apollo.MutationFunction<UpdateSharetypeMutation, UpdateSharetypeMutationVariables>;\n\n/**\n * __useUpdateSharetypeMutation__\n *\n * To run a mutation, you first call `useUpdateSharetypeMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateSharetypeMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateSharetypeMutation, { data, loading, error }] = useUpdateSharetypeMutation({\n *   variables: {\n *      updateSharetypeData: // value for 'updateSharetypeData'\n *   },\n * });\n */\nexport function useUpdateSharetypeMutation(baseOptions?: Apollo.MutationHookOptions<UpdateSharetypeMutation, UpdateSharetypeMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateSharetypeMutation, UpdateSharetypeMutationVariables>(UpdateSharetypeDocument, options);\n      }\nexport type UpdateSharetypeMutationHookResult = ReturnType<typeof useUpdateSharetypeMutation>;\nexport type UpdateSharetypeMutationResult = Apollo.MutationResult<UpdateSharetypeMutation>;\nexport type UpdateSharetypeMutationOptions = Apollo.BaseMutationOptions<UpdateSharetypeMutation, UpdateSharetypeMutationVariables>;\nexport const AddNewSharetypeDocument: TypedDocumentNode<AddNewSharetypeMutation, AddNewSharetypeMutationVariables> = gql`\n  mutation addNewSharetype($createSharetypeData: CreateShareTypeInput!) {\n  createShareType(createSharetypeData: $createSharetypeData) {\n    sharetype {\n      id\n      name\n      symbol\n    }\n  }\n}\n    `;\nexport type AddNewSharetypeMutationFn = Apollo.MutationFunction<AddNewSharetypeMutation, AddNewSharetypeMutationVariables>;\n\n/**\n * __useAddNewSharetypeMutation__\n *\n * To run a mutation, you first call `useAddNewSharetypeMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddNewSharetypeMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addNewSharetypeMutation, { data, loading, error }] = useAddNewSharetypeMutation({\n *   variables: {\n *      createSharetypeData: // value for 'createSharetypeData'\n *   },\n * });\n */\nexport function useAddNewSharetypeMutation(baseOptions?: Apollo.MutationHookOptions<AddNewSharetypeMutation, AddNewSharetypeMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddNewSharetypeMutation, AddNewSharetypeMutationVariables>(AddNewSharetypeDocument, options);\n      }\nexport type AddNewSharetypeMutationHookResult = ReturnType<typeof useAddNewSharetypeMutation>;\nexport type AddNewSharetypeMutationResult = Apollo.MutationResult<AddNewSharetypeMutation>;\nexport type AddNewSharetypeMutationOptions = Apollo.BaseMutationOptions<AddNewSharetypeMutation, AddNewSharetypeMutationVariables>;\nexport const DeleteTransactionsDocument: TypedDocumentNode<DeleteTransactionsMutation, DeleteTransactionsMutationVariables> = gql`\n  mutation deleteTransactions($organisationId: UUID!, $transactionIds: [UUID!]!, $transactionType: String!) {\n  deleteTransactions(\n    organisationId: $organisationId\n    transactionIds: $transactionIds\n    transactionType: $transactionType\n  )\n}\n    `;\nexport type DeleteTransactionsMutationFn = Apollo.MutationFunction<DeleteTransactionsMutation, DeleteTransactionsMutationVariables>;\n\n/**\n * __useDeleteTransactionsMutation__\n *\n * To run a mutation, you first call `useDeleteTransactionsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteTransactionsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteTransactionsMutation, { data, loading, error }] = useDeleteTransactionsMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      transactionIds: // value for 'transactionIds'\n *      transactionType: // value for 'transactionType'\n *   },\n * });\n */\nexport function useDeleteTransactionsMutation(baseOptions?: Apollo.MutationHookOptions<DeleteTransactionsMutation, DeleteTransactionsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteTransactionsMutation, DeleteTransactionsMutationVariables>(DeleteTransactionsDocument, options);\n      }\nexport type DeleteTransactionsMutationHookResult = ReturnType<typeof useDeleteTransactionsMutation>;\nexport type DeleteTransactionsMutationResult = Apollo.MutationResult<DeleteTransactionsMutation>;\nexport type DeleteTransactionsMutationOptions = Apollo.BaseMutationOptions<DeleteTransactionsMutation, DeleteTransactionsMutationVariables>;\nexport const DeleteOfficeholderDocument: TypedDocumentNode<DeleteOfficeholderMutation, DeleteOfficeholderMutationVariables> = gql`\n  mutation deleteOfficeholder($officeholder: OfficeholderCakeType!) {\n  deleteOfficeholder(officeholder: $officeholder) {\n    organisation {\n      id\n    }\n  }\n}\n    `;\nexport type DeleteOfficeholderMutationFn = Apollo.MutationFunction<DeleteOfficeholderMutation, DeleteOfficeholderMutationVariables>;\n\n/**\n * __useDeleteOfficeholderMutation__\n *\n * To run a mutation, you first call `useDeleteOfficeholderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteOfficeholderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteOfficeholderMutation, { data, loading, error }] = useDeleteOfficeholderMutation({\n *   variables: {\n *      officeholder: // value for 'officeholder'\n *   },\n * });\n */\nexport function useDeleteOfficeholderMutation(baseOptions?: Apollo.MutationHookOptions<DeleteOfficeholderMutation, DeleteOfficeholderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteOfficeholderMutation, DeleteOfficeholderMutationVariables>(DeleteOfficeholderDocument, options);\n      }\nexport type DeleteOfficeholderMutationHookResult = ReturnType<typeof useDeleteOfficeholderMutation>;\nexport type DeleteOfficeholderMutationResult = Apollo.MutationResult<DeleteOfficeholderMutation>;\nexport type DeleteOfficeholderMutationOptions = Apollo.BaseMutationOptions<DeleteOfficeholderMutation, DeleteOfficeholderMutationVariables>;\nexport const DeleteSharetypeDocument: TypedDocumentNode<DeleteSharetypeMutation, DeleteSharetypeMutationVariables> = gql`\n  mutation deleteSharetype($sharetype: SharetypeCakeType!) {\n  deleteSharetype(sharetype: $sharetype) {\n    ok\n  }\n}\n    `;\nexport type DeleteSharetypeMutationFn = Apollo.MutationFunction<DeleteSharetypeMutation, DeleteSharetypeMutationVariables>;\n\n/**\n * __useDeleteSharetypeMutation__\n *\n * To run a mutation, you first call `useDeleteSharetypeMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteSharetypeMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteSharetypeMutation, { data, loading, error }] = useDeleteSharetypeMutation({\n *   variables: {\n *      sharetype: // value for 'sharetype'\n *   },\n * });\n */\nexport function useDeleteSharetypeMutation(baseOptions?: Apollo.MutationHookOptions<DeleteSharetypeMutation, DeleteSharetypeMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteSharetypeMutation, DeleteSharetypeMutationVariables>(DeleteSharetypeDocument, options);\n      }\nexport type DeleteSharetypeMutationHookResult = ReturnType<typeof useDeleteSharetypeMutation>;\nexport type DeleteSharetypeMutationResult = Apollo.MutationResult<DeleteSharetypeMutation>;\nexport type DeleteSharetypeMutationOptions = Apollo.BaseMutationOptions<DeleteSharetypeMutation, DeleteSharetypeMutationVariables>;\nexport const OrganisationSupportSearchDocument: TypedDocumentNode<OrganisationSupportSearchQuery, OrganisationSupportSearchQueryVariables> = gql`\n  query organisationSupportSearch($search: String!) {\n  organisationSupportSearch(search: $search) {\n    id\n    name\n    license {\n      internalId\n    }\n  }\n}\n    `;\n\n/**\n * __useOrganisationSupportSearchQuery__\n *\n * To run a query within a React component, call `useOrganisationSupportSearchQuery` and pass it any options that fit your needs.\n * When your component renders, `useOrganisationSupportSearchQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOrganisationSupportSearchQuery({\n *   variables: {\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useOrganisationSupportSearchQuery(baseOptions: Apollo.QueryHookOptions<OrganisationSupportSearchQuery, OrganisationSupportSearchQueryVariables> & ({ variables: OrganisationSupportSearchQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OrganisationSupportSearchQuery, OrganisationSupportSearchQueryVariables>(OrganisationSupportSearchDocument, options);\n      }\nexport function useOrganisationSupportSearchLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OrganisationSupportSearchQuery, OrganisationSupportSearchQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OrganisationSupportSearchQuery, OrganisationSupportSearchQueryVariables>(OrganisationSupportSearchDocument, options);\n        }\nexport function useOrganisationSupportSearchSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OrganisationSupportSearchQuery, OrganisationSupportSearchQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OrganisationSupportSearchQuery, OrganisationSupportSearchQueryVariables>(OrganisationSupportSearchDocument, options);\n        }\nexport type OrganisationSupportSearchQueryHookResult = ReturnType<typeof useOrganisationSupportSearchQuery>;\nexport type OrganisationSupportSearchLazyQueryHookResult = ReturnType<typeof useOrganisationSupportSearchLazyQuery>;\nexport type OrganisationSupportSearchSuspenseQueryHookResult = ReturnType<typeof useOrganisationSupportSearchSuspenseQuery>;\nexport type OrganisationSupportSearchQueryResult = Apollo.QueryResult<OrganisationSupportSearchQuery, OrganisationSupportSearchQueryVariables>;\nexport function refetchOrganisationSupportSearchQuery(variables: OrganisationSupportSearchQueryVariables) {\n      return { query: OrganisationSupportSearchDocument, variables: variables };\n    }\nexport const DeleteSupportRolesDocument: TypedDocumentNode<DeleteSupportRolesMutation, DeleteSupportRolesMutationVariables> = gql`\n  mutation deleteSupportRoles($roleIdList: [UUID!]!) {\n  deleteSupportRoles(roleIdList: $roleIdList)\n}\n    `;\nexport type DeleteSupportRolesMutationFn = Apollo.MutationFunction<DeleteSupportRolesMutation, DeleteSupportRolesMutationVariables>;\n\n/**\n * __useDeleteSupportRolesMutation__\n *\n * To run a mutation, you first call `useDeleteSupportRolesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteSupportRolesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteSupportRolesMutation, { data, loading, error }] = useDeleteSupportRolesMutation({\n *   variables: {\n *      roleIdList: // value for 'roleIdList'\n *   },\n * });\n */\nexport function useDeleteSupportRolesMutation(baseOptions?: Apollo.MutationHookOptions<DeleteSupportRolesMutation, DeleteSupportRolesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteSupportRolesMutation, DeleteSupportRolesMutationVariables>(DeleteSupportRolesDocument, options);\n      }\nexport type DeleteSupportRolesMutationHookResult = ReturnType<typeof useDeleteSupportRolesMutation>;\nexport type DeleteSupportRolesMutationResult = Apollo.MutationResult<DeleteSupportRolesMutation>;\nexport type DeleteSupportRolesMutationOptions = Apollo.BaseMutationOptions<DeleteSupportRolesMutation, DeleteSupportRolesMutationVariables>;\nexport const DeleteAllSupportRolesDocument: TypedDocumentNode<DeleteAllSupportRolesMutation, DeleteAllSupportRolesMutationVariables> = gql`\n  mutation deleteAllSupportRoles($expiredOnly: Boolean) {\n  deleteAllSupportRoles(expiredOnly: $expiredOnly)\n}\n    `;\nexport type DeleteAllSupportRolesMutationFn = Apollo.MutationFunction<DeleteAllSupportRolesMutation, DeleteAllSupportRolesMutationVariables>;\n\n/**\n * __useDeleteAllSupportRolesMutation__\n *\n * To run a mutation, you first call `useDeleteAllSupportRolesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteAllSupportRolesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteAllSupportRolesMutation, { data, loading, error }] = useDeleteAllSupportRolesMutation({\n *   variables: {\n *      expiredOnly: // value for 'expiredOnly'\n *   },\n * });\n */\nexport function useDeleteAllSupportRolesMutation(baseOptions?: Apollo.MutationHookOptions<DeleteAllSupportRolesMutation, DeleteAllSupportRolesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteAllSupportRolesMutation, DeleteAllSupportRolesMutationVariables>(DeleteAllSupportRolesDocument, options);\n      }\nexport type DeleteAllSupportRolesMutationHookResult = ReturnType<typeof useDeleteAllSupportRolesMutation>;\nexport type DeleteAllSupportRolesMutationResult = Apollo.MutationResult<DeleteAllSupportRolesMutation>;\nexport type DeleteAllSupportRolesMutationOptions = Apollo.BaseMutationOptions<DeleteAllSupportRolesMutation, DeleteAllSupportRolesMutationVariables>;\nexport const GetSupportAdminEntriesDocument: TypedDocumentNode<GetSupportAdminEntriesQuery, GetSupportAdminEntriesQueryVariables> = gql`\n  query getSupportAdminEntries {\n  supportAdminEntries {\n    id\n    role\n    expire\n    organisation {\n      id\n      name\n      license {\n        internalId\n        investorCount\n        maxInvestors\n      }\n      uploadInProgress\n      hideUpcomingInvoice\n      logoImageInternal: logoImage\n      logoImage: logoImageLink\n      logoDeprecated: logo\n    }\n  }\n}\n    `;\n\n/**\n * __useGetSupportAdminEntriesQuery__\n *\n * To run a query within a React component, call `useGetSupportAdminEntriesQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetSupportAdminEntriesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetSupportAdminEntriesQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useGetSupportAdminEntriesQuery(baseOptions?: Apollo.QueryHookOptions<GetSupportAdminEntriesQuery, GetSupportAdminEntriesQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetSupportAdminEntriesQuery, GetSupportAdminEntriesQueryVariables>(GetSupportAdminEntriesDocument, options);\n      }\nexport function useGetSupportAdminEntriesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetSupportAdminEntriesQuery, GetSupportAdminEntriesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetSupportAdminEntriesQuery, GetSupportAdminEntriesQueryVariables>(GetSupportAdminEntriesDocument, options);\n        }\nexport function useGetSupportAdminEntriesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetSupportAdminEntriesQuery, GetSupportAdminEntriesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetSupportAdminEntriesQuery, GetSupportAdminEntriesQueryVariables>(GetSupportAdminEntriesDocument, options);\n        }\nexport type GetSupportAdminEntriesQueryHookResult = ReturnType<typeof useGetSupportAdminEntriesQuery>;\nexport type GetSupportAdminEntriesLazyQueryHookResult = ReturnType<typeof useGetSupportAdminEntriesLazyQuery>;\nexport type GetSupportAdminEntriesSuspenseQueryHookResult = ReturnType<typeof useGetSupportAdminEntriesSuspenseQuery>;\nexport type GetSupportAdminEntriesQueryResult = Apollo.QueryResult<GetSupportAdminEntriesQuery, GetSupportAdminEntriesQueryVariables>;\nexport function refetchGetSupportAdminEntriesQuery(variables?: GetSupportAdminEntriesQueryVariables) {\n      return { query: GetSupportAdminEntriesDocument, variables: variables };\n    }\nexport const GetSupportedShareholdersDocument: TypedDocumentNode<GetSupportedShareholdersQuery, GetSupportedShareholdersQueryVariables> = gql`\n  query getSupportedShareholders {\n  getSupportedShareholders {\n    id\n    displayName\n    organisation {\n      name\n    }\n  }\n}\n    `;\n\n/**\n * __useGetSupportedShareholdersQuery__\n *\n * To run a query within a React component, call `useGetSupportedShareholdersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetSupportedShareholdersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetSupportedShareholdersQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useGetSupportedShareholdersQuery(baseOptions?: Apollo.QueryHookOptions<GetSupportedShareholdersQuery, GetSupportedShareholdersQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetSupportedShareholdersQuery, GetSupportedShareholdersQueryVariables>(GetSupportedShareholdersDocument, options);\n      }\nexport function useGetSupportedShareholdersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetSupportedShareholdersQuery, GetSupportedShareholdersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetSupportedShareholdersQuery, GetSupportedShareholdersQueryVariables>(GetSupportedShareholdersDocument, options);\n        }\nexport function useGetSupportedShareholdersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetSupportedShareholdersQuery, GetSupportedShareholdersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetSupportedShareholdersQuery, GetSupportedShareholdersQueryVariables>(GetSupportedShareholdersDocument, options);\n        }\nexport type GetSupportedShareholdersQueryHookResult = ReturnType<typeof useGetSupportedShareholdersQuery>;\nexport type GetSupportedShareholdersLazyQueryHookResult = ReturnType<typeof useGetSupportedShareholdersLazyQuery>;\nexport type GetSupportedShareholdersSuspenseQueryHookResult = ReturnType<typeof useGetSupportedShareholdersSuspenseQuery>;\nexport type GetSupportedShareholdersQueryResult = Apollo.QueryResult<GetSupportedShareholdersQuery, GetSupportedShareholdersQueryVariables>;\nexport function refetchGetSupportedShareholdersQuery(variables?: GetSupportedShareholdersQueryVariables) {\n      return { query: GetSupportedShareholdersDocument, variables: variables };\n    }\nexport const AddSupportToShareholderDocument: TypedDocumentNode<AddSupportToShareholderMutation, AddSupportToShareholderMutationVariables> = gql`\n  mutation addSupportToShareholder($shareholder: ShareholderCakeType!) {\n  addSupportToShareholder(shareholder: $shareholder)\n}\n    `;\nexport type AddSupportToShareholderMutationFn = Apollo.MutationFunction<AddSupportToShareholderMutation, AddSupportToShareholderMutationVariables>;\n\n/**\n * __useAddSupportToShareholderMutation__\n *\n * To run a mutation, you first call `useAddSupportToShareholderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddSupportToShareholderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addSupportToShareholderMutation, { data, loading, error }] = useAddSupportToShareholderMutation({\n *   variables: {\n *      shareholder: // value for 'shareholder'\n *   },\n * });\n */\nexport function useAddSupportToShareholderMutation(baseOptions?: Apollo.MutationHookOptions<AddSupportToShareholderMutation, AddSupportToShareholderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddSupportToShareholderMutation, AddSupportToShareholderMutationVariables>(AddSupportToShareholderDocument, options);\n      }\nexport type AddSupportToShareholderMutationHookResult = ReturnType<typeof useAddSupportToShareholderMutation>;\nexport type AddSupportToShareholderMutationResult = Apollo.MutationResult<AddSupportToShareholderMutation>;\nexport type AddSupportToShareholderMutationOptions = Apollo.BaseMutationOptions<AddSupportToShareholderMutation, AddSupportToShareholderMutationVariables>;\nexport const DeleteSupportToShareholderDocument: TypedDocumentNode<DeleteSupportToShareholderMutation, DeleteSupportToShareholderMutationVariables> = gql`\n  mutation deleteSupportToShareholder($shareholder: ShareholderCakeType!) {\n  deleteSupportToShareholder(shareholder: $shareholder)\n}\n    `;\nexport type DeleteSupportToShareholderMutationFn = Apollo.MutationFunction<DeleteSupportToShareholderMutation, DeleteSupportToShareholderMutationVariables>;\n\n/**\n * __useDeleteSupportToShareholderMutation__\n *\n * To run a mutation, you first call `useDeleteSupportToShareholderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteSupportToShareholderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteSupportToShareholderMutation, { data, loading, error }] = useDeleteSupportToShareholderMutation({\n *   variables: {\n *      shareholder: // value for 'shareholder'\n *   },\n * });\n */\nexport function useDeleteSupportToShareholderMutation(baseOptions?: Apollo.MutationHookOptions<DeleteSupportToShareholderMutation, DeleteSupportToShareholderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteSupportToShareholderMutation, DeleteSupportToShareholderMutationVariables>(DeleteSupportToShareholderDocument, options);\n      }\nexport type DeleteSupportToShareholderMutationHookResult = ReturnType<typeof useDeleteSupportToShareholderMutation>;\nexport type DeleteSupportToShareholderMutationResult = Apollo.MutationResult<DeleteSupportToShareholderMutation>;\nexport type DeleteSupportToShareholderMutationOptions = Apollo.BaseMutationOptions<DeleteSupportToShareholderMutation, DeleteSupportToShareholderMutationVariables>;\nexport const SupportDeleteOrganisationDocument: TypedDocumentNode<SupportDeleteOrganisationMutation, SupportDeleteOrganisationMutationVariables> = gql`\n  mutation supportDeleteOrganisation($organisation: OrganisationCakeType!, $confirmation: String!, $reason: CleanString!) {\n  supportDeleteOrganisation(\n    organisation: $organisation\n    confirmation: $confirmation\n    reason: $reason\n  )\n}\n    `;\nexport type SupportDeleteOrganisationMutationFn = Apollo.MutationFunction<SupportDeleteOrganisationMutation, SupportDeleteOrganisationMutationVariables>;\n\n/**\n * __useSupportDeleteOrganisationMutation__\n *\n * To run a mutation, you first call `useSupportDeleteOrganisationMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSupportDeleteOrganisationMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [supportDeleteOrganisationMutation, { data, loading, error }] = useSupportDeleteOrganisationMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      confirmation: // value for 'confirmation'\n *      reason: // value for 'reason'\n *   },\n * });\n */\nexport function useSupportDeleteOrganisationMutation(baseOptions?: Apollo.MutationHookOptions<SupportDeleteOrganisationMutation, SupportDeleteOrganisationMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SupportDeleteOrganisationMutation, SupportDeleteOrganisationMutationVariables>(SupportDeleteOrganisationDocument, options);\n      }\nexport type SupportDeleteOrganisationMutationHookResult = ReturnType<typeof useSupportDeleteOrganisationMutation>;\nexport type SupportDeleteOrganisationMutationResult = Apollo.MutationResult<SupportDeleteOrganisationMutation>;\nexport type SupportDeleteOrganisationMutationOptions = Apollo.BaseMutationOptions<SupportDeleteOrganisationMutation, SupportDeleteOrganisationMutationVariables>;\nexport const UserOrganisationsSupportSearchDocument: TypedDocumentNode<UserOrganisationsSupportSearchQuery, UserOrganisationsSupportSearchQueryVariables> = gql`\n  query userOrganisationsSupportSearch($userEmail: CleanString) {\n  userOrganisationsSupportSearch(userEmail: $userEmail) {\n    organisationId\n    organisationName\n    role\n  }\n}\n    `;\n\n/**\n * __useUserOrganisationsSupportSearchQuery__\n *\n * To run a query within a React component, call `useUserOrganisationsSupportSearchQuery` and pass it any options that fit your needs.\n * When your component renders, `useUserOrganisationsSupportSearchQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useUserOrganisationsSupportSearchQuery({\n *   variables: {\n *      userEmail: // value for 'userEmail'\n *   },\n * });\n */\nexport function useUserOrganisationsSupportSearchQuery(baseOptions?: Apollo.QueryHookOptions<UserOrganisationsSupportSearchQuery, UserOrganisationsSupportSearchQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<UserOrganisationsSupportSearchQuery, UserOrganisationsSupportSearchQueryVariables>(UserOrganisationsSupportSearchDocument, options);\n      }\nexport function useUserOrganisationsSupportSearchLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UserOrganisationsSupportSearchQuery, UserOrganisationsSupportSearchQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<UserOrganisationsSupportSearchQuery, UserOrganisationsSupportSearchQueryVariables>(UserOrganisationsSupportSearchDocument, options);\n        }\nexport function useUserOrganisationsSupportSearchSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserOrganisationsSupportSearchQuery, UserOrganisationsSupportSearchQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<UserOrganisationsSupportSearchQuery, UserOrganisationsSupportSearchQueryVariables>(UserOrganisationsSupportSearchDocument, options);\n        }\nexport type UserOrganisationsSupportSearchQueryHookResult = ReturnType<typeof useUserOrganisationsSupportSearchQuery>;\nexport type UserOrganisationsSupportSearchLazyQueryHookResult = ReturnType<typeof useUserOrganisationsSupportSearchLazyQuery>;\nexport type UserOrganisationsSupportSearchSuspenseQueryHookResult = ReturnType<typeof useUserOrganisationsSupportSearchSuspenseQuery>;\nexport type UserOrganisationsSupportSearchQueryResult = Apollo.QueryResult<UserOrganisationsSupportSearchQuery, UserOrganisationsSupportSearchQueryVariables>;\nexport function refetchUserOrganisationsSupportSearchQuery(variables?: UserOrganisationsSupportSearchQueryVariables) {\n      return { query: UserOrganisationsSupportSearchDocument, variables: variables };\n    }\nexport const OrganisationPreDeletionReportDocument: TypedDocumentNode<OrganisationPreDeletionReportQuery, OrganisationPreDeletionReportQueryVariables> = gql`\n  query organisationPreDeletionReport($organisation: OrganisationCakeType!) {\n  organisationPreDeletionReport(organisation: $organisation) {\n    creationDate\n    dateOfCurrentSubscription\n    hasCancelled\n    isPaused\n    hasPausedBefore\n    numberOfFounderAppUsers\n    numberOfStakeholders\n    stakeholdersInCake\n    numberOfOffers\n    numberOfFiles\n  }\n}\n    `;\n\n/**\n * __useOrganisationPreDeletionReportQuery__\n *\n * To run a query within a React component, call `useOrganisationPreDeletionReportQuery` and pass it any options that fit your needs.\n * When your component renders, `useOrganisationPreDeletionReportQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOrganisationPreDeletionReportQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useOrganisationPreDeletionReportQuery(baseOptions: Apollo.QueryHookOptions<OrganisationPreDeletionReportQuery, OrganisationPreDeletionReportQueryVariables> & ({ variables: OrganisationPreDeletionReportQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OrganisationPreDeletionReportQuery, OrganisationPreDeletionReportQueryVariables>(OrganisationPreDeletionReportDocument, options);\n      }\nexport function useOrganisationPreDeletionReportLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OrganisationPreDeletionReportQuery, OrganisationPreDeletionReportQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OrganisationPreDeletionReportQuery, OrganisationPreDeletionReportQueryVariables>(OrganisationPreDeletionReportDocument, options);\n        }\nexport function useOrganisationPreDeletionReportSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OrganisationPreDeletionReportQuery, OrganisationPreDeletionReportQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OrganisationPreDeletionReportQuery, OrganisationPreDeletionReportQueryVariables>(OrganisationPreDeletionReportDocument, options);\n        }\nexport type OrganisationPreDeletionReportQueryHookResult = ReturnType<typeof useOrganisationPreDeletionReportQuery>;\nexport type OrganisationPreDeletionReportLazyQueryHookResult = ReturnType<typeof useOrganisationPreDeletionReportLazyQuery>;\nexport type OrganisationPreDeletionReportSuspenseQueryHookResult = ReturnType<typeof useOrganisationPreDeletionReportSuspenseQuery>;\nexport type OrganisationPreDeletionReportQueryResult = Apollo.QueryResult<OrganisationPreDeletionReportQuery, OrganisationPreDeletionReportQueryVariables>;\nexport function refetchOrganisationPreDeletionReportQuery(variables: OrganisationPreDeletionReportQueryVariables) {\n      return { query: OrganisationPreDeletionReportDocument, variables: variables };\n    }\nexport const GetTeamDataDocument: TypedDocumentNode<GetTeamDataQuery, GetTeamDataQueryVariables> = gql`\n  query getTeamData($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    usersWithAggregatedRoles {\n      user {\n        id\n        isLoggedInUser\n        email\n        name\n        picture\n      }\n      role\n      position\n    }\n    license {\n      billingEmail\n      billingMobile\n    }\n  }\n  availableOrganisationRoles {\n    roles {\n      role\n      description\n    }\n  }\n  availableOrganisationPositions {\n    positions {\n      position\n      description\n    }\n  }\n  officeholders(organisationId: $organisationId) {\n    id\n    name\n    email\n    avatar\n  }\n  getInvitedUsers(organisationId: $organisationId) {\n    id\n    payloadInviteEmail\n    payloadRole\n    payloadPosition\n  }\n}\n    `;\n\n/**\n * __useGetTeamDataQuery__\n *\n * To run a query within a React component, call `useGetTeamDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetTeamDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetTeamDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetTeamDataQuery(baseOptions: Apollo.QueryHookOptions<GetTeamDataQuery, GetTeamDataQueryVariables> & ({ variables: GetTeamDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetTeamDataQuery, GetTeamDataQueryVariables>(GetTeamDataDocument, options);\n      }\nexport function useGetTeamDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetTeamDataQuery, GetTeamDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetTeamDataQuery, GetTeamDataQueryVariables>(GetTeamDataDocument, options);\n        }\nexport function useGetTeamDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetTeamDataQuery, GetTeamDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetTeamDataQuery, GetTeamDataQueryVariables>(GetTeamDataDocument, options);\n        }\nexport type GetTeamDataQueryHookResult = ReturnType<typeof useGetTeamDataQuery>;\nexport type GetTeamDataLazyQueryHookResult = ReturnType<typeof useGetTeamDataLazyQuery>;\nexport type GetTeamDataSuspenseQueryHookResult = ReturnType<typeof useGetTeamDataSuspenseQuery>;\nexport type GetTeamDataQueryResult = Apollo.QueryResult<GetTeamDataQuery, GetTeamDataQueryVariables>;\nexport function refetchGetTeamDataQuery(variables: GetTeamDataQueryVariables) {\n      return { query: GetTeamDataDocument, variables: variables };\n    }\nexport const GetInvitedUsersDocument: TypedDocumentNode<GetInvitedUsersQuery, GetInvitedUsersQueryVariables> = gql`\n  query getInvitedUsers($organisationId: UUID!) {\n  getInvitedUsers(organisationId: $organisationId) {\n    id\n    payloadInviteEmail\n    payloadRole\n    payloadPosition\n  }\n}\n    `;\n\n/**\n * __useGetInvitedUsersQuery__\n *\n * To run a query within a React component, call `useGetInvitedUsersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetInvitedUsersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetInvitedUsersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetInvitedUsersQuery(baseOptions: Apollo.QueryHookOptions<GetInvitedUsersQuery, GetInvitedUsersQueryVariables> & ({ variables: GetInvitedUsersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetInvitedUsersQuery, GetInvitedUsersQueryVariables>(GetInvitedUsersDocument, options);\n      }\nexport function useGetInvitedUsersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetInvitedUsersQuery, GetInvitedUsersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetInvitedUsersQuery, GetInvitedUsersQueryVariables>(GetInvitedUsersDocument, options);\n        }\nexport function useGetInvitedUsersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetInvitedUsersQuery, GetInvitedUsersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetInvitedUsersQuery, GetInvitedUsersQueryVariables>(GetInvitedUsersDocument, options);\n        }\nexport type GetInvitedUsersQueryHookResult = ReturnType<typeof useGetInvitedUsersQuery>;\nexport type GetInvitedUsersLazyQueryHookResult = ReturnType<typeof useGetInvitedUsersLazyQuery>;\nexport type GetInvitedUsersSuspenseQueryHookResult = ReturnType<typeof useGetInvitedUsersSuspenseQuery>;\nexport type GetInvitedUsersQueryResult = Apollo.QueryResult<GetInvitedUsersQuery, GetInvitedUsersQueryVariables>;\nexport function refetchGetInvitedUsersQuery(variables: GetInvitedUsersQueryVariables) {\n      return { query: GetInvitedUsersDocument, variables: variables };\n    }\nexport const GetUserOrganisationsDocument: TypedDocumentNode<GetUserOrganisationsQuery, GetUserOrganisationsQueryVariables> = gql`\n  query getUserOrganisations {\n  viewEditOrganisations {\n    id\n    created\n    name\n    country\n    currency\n    userRoles {\n      role\n    }\n    license {\n      internalId\n    }\n    logoImageInternal: logoImage\n    logoImage: logoImageLink\n    logoDeprecated: logo\n    partner {\n      logo\n    }\n  }\n}\n    `;\n\n/**\n * __useGetUserOrganisationsQuery__\n *\n * To run a query within a React component, call `useGetUserOrganisationsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetUserOrganisationsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetUserOrganisationsQuery({\n *   variables: {\n *   },\n * });\n */\nexport function useGetUserOrganisationsQuery(baseOptions?: Apollo.QueryHookOptions<GetUserOrganisationsQuery, GetUserOrganisationsQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetUserOrganisationsQuery, GetUserOrganisationsQueryVariables>(GetUserOrganisationsDocument, options);\n      }\nexport function useGetUserOrganisationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUserOrganisationsQuery, GetUserOrganisationsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetUserOrganisationsQuery, GetUserOrganisationsQueryVariables>(GetUserOrganisationsDocument, options);\n        }\nexport function useGetUserOrganisationsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetUserOrganisationsQuery, GetUserOrganisationsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetUserOrganisationsQuery, GetUserOrganisationsQueryVariables>(GetUserOrganisationsDocument, options);\n        }\nexport type GetUserOrganisationsQueryHookResult = ReturnType<typeof useGetUserOrganisationsQuery>;\nexport type GetUserOrganisationsLazyQueryHookResult = ReturnType<typeof useGetUserOrganisationsLazyQuery>;\nexport type GetUserOrganisationsSuspenseQueryHookResult = ReturnType<typeof useGetUserOrganisationsSuspenseQuery>;\nexport type GetUserOrganisationsQueryResult = Apollo.QueryResult<GetUserOrganisationsQuery, GetUserOrganisationsQueryVariables>;\nexport function refetchGetUserOrganisationsQuery(variables?: GetUserOrganisationsQueryVariables) {\n      return { query: GetUserOrganisationsDocument, variables: variables };\n    }\nexport const GetUserAdminOrganisationsDocument: TypedDocumentNode<GetUserAdminOrganisationsQuery, GetUserAdminOrganisationsQueryVariables> = gql`\n  query getUserAdminOrganisations($page: Int, $itemsPerPage: Int) {\n  adminOrganisations(page: $page, itemsPerPage: $itemsPerPage) {\n    id\n    name\n    logo\n    created\n    modified\n    usersWithAggregatedRoles {\n      user {\n        id\n        isLoggedInUser\n        email\n        name\n        picture\n      }\n      role\n    }\n  }\n  availableOrganisationRoles {\n    roles {\n      role\n      description\n    }\n  }\n}\n    `;\n\n/**\n * __useGetUserAdminOrganisationsQuery__\n *\n * To run a query within a React component, call `useGetUserAdminOrganisationsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetUserAdminOrganisationsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetUserAdminOrganisationsQuery({\n *   variables: {\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetUserAdminOrganisationsQuery(baseOptions?: Apollo.QueryHookOptions<GetUserAdminOrganisationsQuery, GetUserAdminOrganisationsQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetUserAdminOrganisationsQuery, GetUserAdminOrganisationsQueryVariables>(GetUserAdminOrganisationsDocument, options);\n      }\nexport function useGetUserAdminOrganisationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUserAdminOrganisationsQuery, GetUserAdminOrganisationsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetUserAdminOrganisationsQuery, GetUserAdminOrganisationsQueryVariables>(GetUserAdminOrganisationsDocument, options);\n        }\nexport function useGetUserAdminOrganisationsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetUserAdminOrganisationsQuery, GetUserAdminOrganisationsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetUserAdminOrganisationsQuery, GetUserAdminOrganisationsQueryVariables>(GetUserAdminOrganisationsDocument, options);\n        }\nexport type GetUserAdminOrganisationsQueryHookResult = ReturnType<typeof useGetUserAdminOrganisationsQuery>;\nexport type GetUserAdminOrganisationsLazyQueryHookResult = ReturnType<typeof useGetUserAdminOrganisationsLazyQuery>;\nexport type GetUserAdminOrganisationsSuspenseQueryHookResult = ReturnType<typeof useGetUserAdminOrganisationsSuspenseQuery>;\nexport type GetUserAdminOrganisationsQueryResult = Apollo.QueryResult<GetUserAdminOrganisationsQuery, GetUserAdminOrganisationsQueryVariables>;\nexport function refetchGetUserAdminOrganisationsQuery(variables?: GetUserAdminOrganisationsQueryVariables) {\n      return { query: GetUserAdminOrganisationsDocument, variables: variables };\n    }\nexport const InviteUsersDocument: TypedDocumentNode<InviteUsersMutation, InviteUsersMutationVariables> = gql`\n  mutation inviteUsers($organisation: OrganisationCakeType!, $invitedUsers: [InvitedUserInput]!) {\n  inviteUsers(organisation: $organisation, invitedUsers: $invitedUsers) {\n    invites {\n      id\n      payloadInviteEmail\n      payloadRole\n      payloadPosition\n    }\n  }\n}\n    `;\nexport type InviteUsersMutationFn = Apollo.MutationFunction<InviteUsersMutation, InviteUsersMutationVariables>;\n\n/**\n * __useInviteUsersMutation__\n *\n * To run a mutation, you first call `useInviteUsersMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useInviteUsersMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [inviteUsersMutation, { data, loading, error }] = useInviteUsersMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      invitedUsers: // value for 'invitedUsers'\n *   },\n * });\n */\nexport function useInviteUsersMutation(baseOptions?: Apollo.MutationHookOptions<InviteUsersMutation, InviteUsersMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<InviteUsersMutation, InviteUsersMutationVariables>(InviteUsersDocument, options);\n      }\nexport type InviteUsersMutationHookResult = ReturnType<typeof useInviteUsersMutation>;\nexport type InviteUsersMutationResult = Apollo.MutationResult<InviteUsersMutation>;\nexport type InviteUsersMutationOptions = Apollo.BaseMutationOptions<InviteUsersMutation, InviteUsersMutationVariables>;\nexport const InviteJoinCakeDocument: TypedDocumentNode<InviteJoinCakeMutation, InviteJoinCakeMutationVariables> = gql`\n  mutation inviteJoinCake($organisationId: OrganisationCakeType!, $investorIds: [UUID!]!, $emailsForInvestors: [InvitedShareholderEmailInput!], $selectionSearch: String) {\n  inviteJoinCake(\n    organisation: $organisationId\n    investorIds: $investorIds\n    emailsForInvestors: $emailsForInvestors\n    selectionSearch: $selectionSearch\n  ) {\n    numInvited\n  }\n}\n    `;\nexport type InviteJoinCakeMutationFn = Apollo.MutationFunction<InviteJoinCakeMutation, InviteJoinCakeMutationVariables>;\n\n/**\n * __useInviteJoinCakeMutation__\n *\n * To run a mutation, you first call `useInviteJoinCakeMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useInviteJoinCakeMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [inviteJoinCakeMutation, { data, loading, error }] = useInviteJoinCakeMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      investorIds: // value for 'investorIds'\n *      emailsForInvestors: // value for 'emailsForInvestors'\n *      selectionSearch: // value for 'selectionSearch'\n *   },\n * });\n */\nexport function useInviteJoinCakeMutation(baseOptions?: Apollo.MutationHookOptions<InviteJoinCakeMutation, InviteJoinCakeMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<InviteJoinCakeMutation, InviteJoinCakeMutationVariables>(InviteJoinCakeDocument, options);\n      }\nexport type InviteJoinCakeMutationHookResult = ReturnType<typeof useInviteJoinCakeMutation>;\nexport type InviteJoinCakeMutationResult = Apollo.MutationResult<InviteJoinCakeMutation>;\nexport type InviteJoinCakeMutationOptions = Apollo.BaseMutationOptions<InviteJoinCakeMutation, InviteJoinCakeMutationVariables>;\nexport const SendTestTransactionalEmailDocument: TypedDocumentNode<SendTestTransactionalEmailMutation, SendTestTransactionalEmailMutationVariables> = gql`\n  mutation sendTestTransactionalEmail($organisationId: UUID!, $templateSlug: CustomerIOMailTemplates!) {\n  sendTestTransactionalEmail(\n    organisationId: $organisationId\n    templateSlug: $templateSlug\n  ) {\n    ok\n  }\n}\n    `;\nexport type SendTestTransactionalEmailMutationFn = Apollo.MutationFunction<SendTestTransactionalEmailMutation, SendTestTransactionalEmailMutationVariables>;\n\n/**\n * __useSendTestTransactionalEmailMutation__\n *\n * To run a mutation, you first call `useSendTestTransactionalEmailMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSendTestTransactionalEmailMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [sendTestTransactionalEmailMutation, { data, loading, error }] = useSendTestTransactionalEmailMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      templateSlug: // value for 'templateSlug'\n *   },\n * });\n */\nexport function useSendTestTransactionalEmailMutation(baseOptions?: Apollo.MutationHookOptions<SendTestTransactionalEmailMutation, SendTestTransactionalEmailMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SendTestTransactionalEmailMutation, SendTestTransactionalEmailMutationVariables>(SendTestTransactionalEmailDocument, options);\n      }\nexport type SendTestTransactionalEmailMutationHookResult = ReturnType<typeof useSendTestTransactionalEmailMutation>;\nexport type SendTestTransactionalEmailMutationResult = Apollo.MutationResult<SendTestTransactionalEmailMutation>;\nexport type SendTestTransactionalEmailMutationOptions = Apollo.BaseMutationOptions<SendTestTransactionalEmailMutation, SendTestTransactionalEmailMutationVariables>;\nexport const UpdateOrganisationUserRoleDocument: TypedDocumentNode<UpdateOrganisationUserRoleMutation, UpdateOrganisationUserRoleMutationVariables> = gql`\n  mutation updateOrganisationUserRole($organisationId: OrganisationCakeType!, $userId: UserCakeType!, $role: CleanString!, $position: CleanString!) {\n  updateOrganisationUserRole(\n    user: $userId\n    organisation: $organisationId\n    role: $role\n    position: $position\n  )\n}\n    `;\nexport type UpdateOrganisationUserRoleMutationFn = Apollo.MutationFunction<UpdateOrganisationUserRoleMutation, UpdateOrganisationUserRoleMutationVariables>;\n\n/**\n * __useUpdateOrganisationUserRoleMutation__\n *\n * To run a mutation, you first call `useUpdateOrganisationUserRoleMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOrganisationUserRoleMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOrganisationUserRoleMutation, { data, loading, error }] = useUpdateOrganisationUserRoleMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      userId: // value for 'userId'\n *      role: // value for 'role'\n *      position: // value for 'position'\n *   },\n * });\n */\nexport function useUpdateOrganisationUserRoleMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOrganisationUserRoleMutation, UpdateOrganisationUserRoleMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOrganisationUserRoleMutation, UpdateOrganisationUserRoleMutationVariables>(UpdateOrganisationUserRoleDocument, options);\n      }\nexport type UpdateOrganisationUserRoleMutationHookResult = ReturnType<typeof useUpdateOrganisationUserRoleMutation>;\nexport type UpdateOrganisationUserRoleMutationResult = Apollo.MutationResult<UpdateOrganisationUserRoleMutation>;\nexport type UpdateOrganisationUserRoleMutationOptions = Apollo.BaseMutationOptions<UpdateOrganisationUserRoleMutation, UpdateOrganisationUserRoleMutationVariables>;\nexport const ConfirmUserInviteDocument: TypedDocumentNode<ConfirmUserInviteMutation, ConfirmUserInviteMutationVariables> = gql`\n  mutation confirmUserInvite($inviteId: UUID!, $code: String!) {\n  confirmUserInvite(inviteId: $inviteId, code: $code) {\n    ok\n  }\n}\n    `;\nexport type ConfirmUserInviteMutationFn = Apollo.MutationFunction<ConfirmUserInviteMutation, ConfirmUserInviteMutationVariables>;\n\n/**\n * __useConfirmUserInviteMutation__\n *\n * To run a mutation, you first call `useConfirmUserInviteMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useConfirmUserInviteMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [confirmUserInviteMutation, { data, loading, error }] = useConfirmUserInviteMutation({\n *   variables: {\n *      inviteId: // value for 'inviteId'\n *      code: // value for 'code'\n *   },\n * });\n */\nexport function useConfirmUserInviteMutation(baseOptions?: Apollo.MutationHookOptions<ConfirmUserInviteMutation, ConfirmUserInviteMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ConfirmUserInviteMutation, ConfirmUserInviteMutationVariables>(ConfirmUserInviteDocument, options);\n      }\nexport type ConfirmUserInviteMutationHookResult = ReturnType<typeof useConfirmUserInviteMutation>;\nexport type ConfirmUserInviteMutationResult = Apollo.MutationResult<ConfirmUserInviteMutation>;\nexport type ConfirmUserInviteMutationOptions = Apollo.BaseMutationOptions<ConfirmUserInviteMutation, ConfirmUserInviteMutationVariables>;\nexport const ClearUserInviteSenderDocument: TypedDocumentNode<ClearUserInviteSenderMutation, ClearUserInviteSenderMutationVariables> = gql`\n  mutation clearUserInviteSender {\n  clearUserInviteSender\n}\n    `;\nexport type ClearUserInviteSenderMutationFn = Apollo.MutationFunction<ClearUserInviteSenderMutation, ClearUserInviteSenderMutationVariables>;\n\n/**\n * __useClearUserInviteSenderMutation__\n *\n * To run a mutation, you first call `useClearUserInviteSenderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useClearUserInviteSenderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [clearUserInviteSenderMutation, { data, loading, error }] = useClearUserInviteSenderMutation({\n *   variables: {\n *   },\n * });\n */\nexport function useClearUserInviteSenderMutation(baseOptions?: Apollo.MutationHookOptions<ClearUserInviteSenderMutation, ClearUserInviteSenderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ClearUserInviteSenderMutation, ClearUserInviteSenderMutationVariables>(ClearUserInviteSenderDocument, options);\n      }\nexport type ClearUserInviteSenderMutationHookResult = ReturnType<typeof useClearUserInviteSenderMutation>;\nexport type ClearUserInviteSenderMutationResult = Apollo.MutationResult<ClearUserInviteSenderMutation>;\nexport type ClearUserInviteSenderMutationOptions = Apollo.BaseMutationOptions<ClearUserInviteSenderMutation, ClearUserInviteSenderMutationVariables>;\nexport const RevokeUserInvitationDocument: TypedDocumentNode<RevokeUserInvitationMutation, RevokeUserInvitationMutationVariables> = gql`\n  mutation revokeUserInvitation($invite: EmailSenderCakeType!) {\n  revokeUserInvitation(invite: $invite)\n}\n    `;\nexport type RevokeUserInvitationMutationFn = Apollo.MutationFunction<RevokeUserInvitationMutation, RevokeUserInvitationMutationVariables>;\n\n/**\n * __useRevokeUserInvitationMutation__\n *\n * To run a mutation, you first call `useRevokeUserInvitationMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRevokeUserInvitationMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [revokeUserInvitationMutation, { data, loading, error }] = useRevokeUserInvitationMutation({\n *   variables: {\n *      invite: // value for 'invite'\n *   },\n * });\n */\nexport function useRevokeUserInvitationMutation(baseOptions?: Apollo.MutationHookOptions<RevokeUserInvitationMutation, RevokeUserInvitationMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RevokeUserInvitationMutation, RevokeUserInvitationMutationVariables>(RevokeUserInvitationDocument, options);\n      }\nexport type RevokeUserInvitationMutationHookResult = ReturnType<typeof useRevokeUserInvitationMutation>;\nexport type RevokeUserInvitationMutationResult = Apollo.MutationResult<RevokeUserInvitationMutation>;\nexport type RevokeUserInvitationMutationOptions = Apollo.BaseMutationOptions<RevokeUserInvitationMutation, RevokeUserInvitationMutationVariables>;\nexport const RemoveOrganisationUserRolesDocument: TypedDocumentNode<RemoveOrganisationUserRolesMutation, RemoveOrganisationUserRolesMutationVariables> = gql`\n  mutation removeOrganisationUserRoles($organisationId: OrganisationCakeType!, $userId: UserCakeType!) {\n  removeOrganisationUserRoles(user: $userId, organisation: $organisationId)\n}\n    `;\nexport type RemoveOrganisationUserRolesMutationFn = Apollo.MutationFunction<RemoveOrganisationUserRolesMutation, RemoveOrganisationUserRolesMutationVariables>;\n\n/**\n * __useRemoveOrganisationUserRolesMutation__\n *\n * To run a mutation, you first call `useRemoveOrganisationUserRolesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRemoveOrganisationUserRolesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [removeOrganisationUserRolesMutation, { data, loading, error }] = useRemoveOrganisationUserRolesMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      userId: // value for 'userId'\n *   },\n * });\n */\nexport function useRemoveOrganisationUserRolesMutation(baseOptions?: Apollo.MutationHookOptions<RemoveOrganisationUserRolesMutation, RemoveOrganisationUserRolesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RemoveOrganisationUserRolesMutation, RemoveOrganisationUserRolesMutationVariables>(RemoveOrganisationUserRolesDocument, options);\n      }\nexport type RemoveOrganisationUserRolesMutationHookResult = ReturnType<typeof useRemoveOrganisationUserRolesMutation>;\nexport type RemoveOrganisationUserRolesMutationResult = Apollo.MutationResult<RemoveOrganisationUserRolesMutation>;\nexport type RemoveOrganisationUserRolesMutationOptions = Apollo.BaseMutationOptions<RemoveOrganisationUserRolesMutation, RemoveOrganisationUserRolesMutationVariables>;\nexport const GetCakeGroupUsersDocument: TypedDocumentNode<GetCakeGroupUsersQuery, GetCakeGroupUsersQueryVariables> = gql`\n  query getCakeGroupUsers($organisationId: UUID!, $filterByGroupId: UUID) {\n  cakeGroups(organisationId: $organisationId, filterByGroupId: $filterByGroupId) {\n    id\n    name\n    groupType\n    users {\n      name\n      email\n      avatar\n      userId\n      userType\n    }\n  }\n}\n    `;\n\n/**\n * __useGetCakeGroupUsersQuery__\n *\n * To run a query within a React component, call `useGetCakeGroupUsersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetCakeGroupUsersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetCakeGroupUsersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      filterByGroupId: // value for 'filterByGroupId'\n *   },\n * });\n */\nexport function useGetCakeGroupUsersQuery(baseOptions: Apollo.QueryHookOptions<GetCakeGroupUsersQuery, GetCakeGroupUsersQueryVariables> & ({ variables: GetCakeGroupUsersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetCakeGroupUsersQuery, GetCakeGroupUsersQueryVariables>(GetCakeGroupUsersDocument, options);\n      }\nexport function useGetCakeGroupUsersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCakeGroupUsersQuery, GetCakeGroupUsersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetCakeGroupUsersQuery, GetCakeGroupUsersQueryVariables>(GetCakeGroupUsersDocument, options);\n        }\nexport function useGetCakeGroupUsersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetCakeGroupUsersQuery, GetCakeGroupUsersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetCakeGroupUsersQuery, GetCakeGroupUsersQueryVariables>(GetCakeGroupUsersDocument, options);\n        }\nexport type GetCakeGroupUsersQueryHookResult = ReturnType<typeof useGetCakeGroupUsersQuery>;\nexport type GetCakeGroupUsersLazyQueryHookResult = ReturnType<typeof useGetCakeGroupUsersLazyQuery>;\nexport type GetCakeGroupUsersSuspenseQueryHookResult = ReturnType<typeof useGetCakeGroupUsersSuspenseQuery>;\nexport type GetCakeGroupUsersQueryResult = Apollo.QueryResult<GetCakeGroupUsersQuery, GetCakeGroupUsersQueryVariables>;\nexport function refetchGetCakeGroupUsersQuery(variables: GetCakeGroupUsersQueryVariables) {\n      return { query: GetCakeGroupUsersDocument, variables: variables };\n    }\nexport const GetCakeGroupsDocument: TypedDocumentNode<GetCakeGroupsQuery, GetCakeGroupsQueryVariables> = gql`\n  query getCakeGroups($organisationId: UUID!) {\n  cakeGroups(organisationId: $organisationId) {\n    id\n    name\n    groupType\n    count\n  }\n}\n    `;\n\n/**\n * __useGetCakeGroupsQuery__\n *\n * To run a query within a React component, call `useGetCakeGroupsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetCakeGroupsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetCakeGroupsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetCakeGroupsQuery(baseOptions: Apollo.QueryHookOptions<GetCakeGroupsQuery, GetCakeGroupsQueryVariables> & ({ variables: GetCakeGroupsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetCakeGroupsQuery, GetCakeGroupsQueryVariables>(GetCakeGroupsDocument, options);\n      }\nexport function useGetCakeGroupsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCakeGroupsQuery, GetCakeGroupsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetCakeGroupsQuery, GetCakeGroupsQueryVariables>(GetCakeGroupsDocument, options);\n        }\nexport function useGetCakeGroupsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetCakeGroupsQuery, GetCakeGroupsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetCakeGroupsQuery, GetCakeGroupsQueryVariables>(GetCakeGroupsDocument, options);\n        }\nexport type GetCakeGroupsQueryHookResult = ReturnType<typeof useGetCakeGroupsQuery>;\nexport type GetCakeGroupsLazyQueryHookResult = ReturnType<typeof useGetCakeGroupsLazyQuery>;\nexport type GetCakeGroupsSuspenseQueryHookResult = ReturnType<typeof useGetCakeGroupsSuspenseQuery>;\nexport type GetCakeGroupsQueryResult = Apollo.QueryResult<GetCakeGroupsQuery, GetCakeGroupsQueryVariables>;\nexport function refetchGetCakeGroupsQuery(variables: GetCakeGroupsQueryVariables) {\n      return { query: GetCakeGroupsDocument, variables: variables };\n    }\nexport const GetCakeGroupsSimpleDocument: TypedDocumentNode<GetCakeGroupsSimpleQuery, GetCakeGroupsSimpleQueryVariables> = gql`\n  query getCakeGroupsSimple($organisationId: UUID!) {\n  cakeGroups(organisationId: $organisationId) {\n    id\n    name\n  }\n}\n    `;\n\n/**\n * __useGetCakeGroupsSimpleQuery__\n *\n * To run a query within a React component, call `useGetCakeGroupsSimpleQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetCakeGroupsSimpleQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetCakeGroupsSimpleQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetCakeGroupsSimpleQuery(baseOptions: Apollo.QueryHookOptions<GetCakeGroupsSimpleQuery, GetCakeGroupsSimpleQueryVariables> & ({ variables: GetCakeGroupsSimpleQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetCakeGroupsSimpleQuery, GetCakeGroupsSimpleQueryVariables>(GetCakeGroupsSimpleDocument, options);\n      }\nexport function useGetCakeGroupsSimpleLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCakeGroupsSimpleQuery, GetCakeGroupsSimpleQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetCakeGroupsSimpleQuery, GetCakeGroupsSimpleQueryVariables>(GetCakeGroupsSimpleDocument, options);\n        }\nexport function useGetCakeGroupsSimpleSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetCakeGroupsSimpleQuery, GetCakeGroupsSimpleQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetCakeGroupsSimpleQuery, GetCakeGroupsSimpleQueryVariables>(GetCakeGroupsSimpleDocument, options);\n        }\nexport type GetCakeGroupsSimpleQueryHookResult = ReturnType<typeof useGetCakeGroupsSimpleQuery>;\nexport type GetCakeGroupsSimpleLazyQueryHookResult = ReturnType<typeof useGetCakeGroupsSimpleLazyQuery>;\nexport type GetCakeGroupsSimpleSuspenseQueryHookResult = ReturnType<typeof useGetCakeGroupsSimpleSuspenseQuery>;\nexport type GetCakeGroupsSimpleQueryResult = Apollo.QueryResult<GetCakeGroupsSimpleQuery, GetCakeGroupsSimpleQueryVariables>;\nexport function refetchGetCakeGroupsSimpleQuery(variables: GetCakeGroupsSimpleQueryVariables) {\n      return { query: GetCakeGroupsSimpleDocument, variables: variables };\n    }\nexport const GetAvailableUsersForCakeGroupDocument: TypedDocumentNode<GetAvailableUsersForCakeGroupQuery, GetAvailableUsersForCakeGroupQueryVariables> = gql`\n  query getAvailableUsersForCakeGroup($organisation: OrganisationCakeType!, $excludeIds: [UUID!], $search: String) {\n  getAvailableUsersForCakeGroup(\n    organisation: $organisation\n    excludeIds: $excludeIds\n    search: $search\n  ) {\n    name\n    email\n    avatar\n    userId\n    userType\n  }\n}\n    `;\n\n/**\n * __useGetAvailableUsersForCakeGroupQuery__\n *\n * To run a query within a React component, call `useGetAvailableUsersForCakeGroupQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetAvailableUsersForCakeGroupQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetAvailableUsersForCakeGroupQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      excludeIds: // value for 'excludeIds'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetAvailableUsersForCakeGroupQuery(baseOptions: Apollo.QueryHookOptions<GetAvailableUsersForCakeGroupQuery, GetAvailableUsersForCakeGroupQueryVariables> & ({ variables: GetAvailableUsersForCakeGroupQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetAvailableUsersForCakeGroupQuery, GetAvailableUsersForCakeGroupQueryVariables>(GetAvailableUsersForCakeGroupDocument, options);\n      }\nexport function useGetAvailableUsersForCakeGroupLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetAvailableUsersForCakeGroupQuery, GetAvailableUsersForCakeGroupQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetAvailableUsersForCakeGroupQuery, GetAvailableUsersForCakeGroupQueryVariables>(GetAvailableUsersForCakeGroupDocument, options);\n        }\nexport function useGetAvailableUsersForCakeGroupSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetAvailableUsersForCakeGroupQuery, GetAvailableUsersForCakeGroupQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetAvailableUsersForCakeGroupQuery, GetAvailableUsersForCakeGroupQueryVariables>(GetAvailableUsersForCakeGroupDocument, options);\n        }\nexport type GetAvailableUsersForCakeGroupQueryHookResult = ReturnType<typeof useGetAvailableUsersForCakeGroupQuery>;\nexport type GetAvailableUsersForCakeGroupLazyQueryHookResult = ReturnType<typeof useGetAvailableUsersForCakeGroupLazyQuery>;\nexport type GetAvailableUsersForCakeGroupSuspenseQueryHookResult = ReturnType<typeof useGetAvailableUsersForCakeGroupSuspenseQuery>;\nexport type GetAvailableUsersForCakeGroupQueryResult = Apollo.QueryResult<GetAvailableUsersForCakeGroupQuery, GetAvailableUsersForCakeGroupQueryVariables>;\nexport function refetchGetAvailableUsersForCakeGroupQuery(variables: GetAvailableUsersForCakeGroupQueryVariables) {\n      return { query: GetAvailableUsersForCakeGroupDocument, variables: variables };\n    }\nexport const GetCakeGroupsWithShareholdersDocument: TypedDocumentNode<GetCakeGroupsWithShareholdersQuery, GetCakeGroupsWithShareholdersQueryVariables> = gql`\n  query getCakeGroupsWithShareholders($organisationId: UUID!) {\n  cakeGroups(organisationId: $organisationId, onlyWithShareholders: true) {\n    id\n    name\n    groupType\n    count\n  }\n}\n    `;\n\n/**\n * __useGetCakeGroupsWithShareholdersQuery__\n *\n * To run a query within a React component, call `useGetCakeGroupsWithShareholdersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetCakeGroupsWithShareholdersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetCakeGroupsWithShareholdersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetCakeGroupsWithShareholdersQuery(baseOptions: Apollo.QueryHookOptions<GetCakeGroupsWithShareholdersQuery, GetCakeGroupsWithShareholdersQueryVariables> & ({ variables: GetCakeGroupsWithShareholdersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetCakeGroupsWithShareholdersQuery, GetCakeGroupsWithShareholdersQueryVariables>(GetCakeGroupsWithShareholdersDocument, options);\n      }\nexport function useGetCakeGroupsWithShareholdersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCakeGroupsWithShareholdersQuery, GetCakeGroupsWithShareholdersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetCakeGroupsWithShareholdersQuery, GetCakeGroupsWithShareholdersQueryVariables>(GetCakeGroupsWithShareholdersDocument, options);\n        }\nexport function useGetCakeGroupsWithShareholdersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetCakeGroupsWithShareholdersQuery, GetCakeGroupsWithShareholdersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetCakeGroupsWithShareholdersQuery, GetCakeGroupsWithShareholdersQueryVariables>(GetCakeGroupsWithShareholdersDocument, options);\n        }\nexport type GetCakeGroupsWithShareholdersQueryHookResult = ReturnType<typeof useGetCakeGroupsWithShareholdersQuery>;\nexport type GetCakeGroupsWithShareholdersLazyQueryHookResult = ReturnType<typeof useGetCakeGroupsWithShareholdersLazyQuery>;\nexport type GetCakeGroupsWithShareholdersSuspenseQueryHookResult = ReturnType<typeof useGetCakeGroupsWithShareholdersSuspenseQuery>;\nexport type GetCakeGroupsWithShareholdersQueryResult = Apollo.QueryResult<GetCakeGroupsWithShareholdersQuery, GetCakeGroupsWithShareholdersQueryVariables>;\nexport function refetchGetCakeGroupsWithShareholdersQuery(variables: GetCakeGroupsWithShareholdersQueryVariables) {\n      return { query: GetCakeGroupsWithShareholdersDocument, variables: variables };\n    }\nexport const CreateCakeGroupDocument: TypedDocumentNode<CreateCakeGroupMutation, CreateCakeGroupMutationVariables> = gql`\n  mutation createCakeGroup($organisationId: UUID!, $groupName: String!, $parentGroupId: UUID) {\n  createCakeGroup(\n    organisationId: $organisationId\n    groupName: $groupName\n    parentGroupId: $parentGroupId\n  ) {\n    ok\n  }\n}\n    `;\nexport type CreateCakeGroupMutationFn = Apollo.MutationFunction<CreateCakeGroupMutation, CreateCakeGroupMutationVariables>;\n\n/**\n * __useCreateCakeGroupMutation__\n *\n * To run a mutation, you first call `useCreateCakeGroupMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateCakeGroupMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createCakeGroupMutation, { data, loading, error }] = useCreateCakeGroupMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      groupName: // value for 'groupName'\n *      parentGroupId: // value for 'parentGroupId'\n *   },\n * });\n */\nexport function useCreateCakeGroupMutation(baseOptions?: Apollo.MutationHookOptions<CreateCakeGroupMutation, CreateCakeGroupMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateCakeGroupMutation, CreateCakeGroupMutationVariables>(CreateCakeGroupDocument, options);\n      }\nexport type CreateCakeGroupMutationHookResult = ReturnType<typeof useCreateCakeGroupMutation>;\nexport type CreateCakeGroupMutationResult = Apollo.MutationResult<CreateCakeGroupMutation>;\nexport type CreateCakeGroupMutationOptions = Apollo.BaseMutationOptions<CreateCakeGroupMutation, CreateCakeGroupMutationVariables>;\nexport const UpdateCakeGroupDocument: TypedDocumentNode<UpdateCakeGroupMutation, UpdateCakeGroupMutationVariables> = gql`\n  mutation updateCakeGroup($groupId: UUID!, $groupName: String!, $toAdd: [GroupUserInputType!], $toRemove: [GroupUserInputType!]) {\n  updateCakeGroup(\n    groupId: $groupId\n    groupName: $groupName\n    toAdd: $toAdd\n    toRemove: $toRemove\n  ) {\n    ok\n  }\n}\n    `;\nexport type UpdateCakeGroupMutationFn = Apollo.MutationFunction<UpdateCakeGroupMutation, UpdateCakeGroupMutationVariables>;\n\n/**\n * __useUpdateCakeGroupMutation__\n *\n * To run a mutation, you first call `useUpdateCakeGroupMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateCakeGroupMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateCakeGroupMutation, { data, loading, error }] = useUpdateCakeGroupMutation({\n *   variables: {\n *      groupId: // value for 'groupId'\n *      groupName: // value for 'groupName'\n *      toAdd: // value for 'toAdd'\n *      toRemove: // value for 'toRemove'\n *   },\n * });\n */\nexport function useUpdateCakeGroupMutation(baseOptions?: Apollo.MutationHookOptions<UpdateCakeGroupMutation, UpdateCakeGroupMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateCakeGroupMutation, UpdateCakeGroupMutationVariables>(UpdateCakeGroupDocument, options);\n      }\nexport type UpdateCakeGroupMutationHookResult = ReturnType<typeof useUpdateCakeGroupMutation>;\nexport type UpdateCakeGroupMutationResult = Apollo.MutationResult<UpdateCakeGroupMutation>;\nexport type UpdateCakeGroupMutationOptions = Apollo.BaseMutationOptions<UpdateCakeGroupMutation, UpdateCakeGroupMutationVariables>;\nexport const DeleteCakeGroupDocument: TypedDocumentNode<DeleteCakeGroupMutation, DeleteCakeGroupMutationVariables> = gql`\n  mutation deleteCakeGroup($groupId: UUID!) {\n  deleteCakeGroup(groupId: $groupId) {\n    ok\n  }\n}\n    `;\nexport type DeleteCakeGroupMutationFn = Apollo.MutationFunction<DeleteCakeGroupMutation, DeleteCakeGroupMutationVariables>;\n\n/**\n * __useDeleteCakeGroupMutation__\n *\n * To run a mutation, you first call `useDeleteCakeGroupMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteCakeGroupMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteCakeGroupMutation, { data, loading, error }] = useDeleteCakeGroupMutation({\n *   variables: {\n *      groupId: // value for 'groupId'\n *   },\n * });\n */\nexport function useDeleteCakeGroupMutation(baseOptions?: Apollo.MutationHookOptions<DeleteCakeGroupMutation, DeleteCakeGroupMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteCakeGroupMutation, DeleteCakeGroupMutationVariables>(DeleteCakeGroupDocument, options);\n      }\nexport type DeleteCakeGroupMutationHookResult = ReturnType<typeof useDeleteCakeGroupMutation>;\nexport type DeleteCakeGroupMutationResult = Apollo.MutationResult<DeleteCakeGroupMutation>;\nexport type DeleteCakeGroupMutationOptions = Apollo.BaseMutationOptions<DeleteCakeGroupMutation, DeleteCakeGroupMutationVariables>;\nexport const HasPendingActionsDocument: TypedDocumentNode<HasPendingActionsQuery, HasPendingActionsQueryVariables> = gql`\n  query hasPendingActions($organisationId: OrganisationCakeType!) {\n  actionItems(organisation: $organisationId) {\n    count\n  }\n}\n    `;\n\n/**\n * __useHasPendingActionsQuery__\n *\n * To run a query within a React component, call `useHasPendingActionsQuery` and pass it any options that fit your needs.\n * When your component renders, `useHasPendingActionsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useHasPendingActionsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useHasPendingActionsQuery(baseOptions: Apollo.QueryHookOptions<HasPendingActionsQuery, HasPendingActionsQueryVariables> & ({ variables: HasPendingActionsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<HasPendingActionsQuery, HasPendingActionsQueryVariables>(HasPendingActionsDocument, options);\n      }\nexport function useHasPendingActionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<HasPendingActionsQuery, HasPendingActionsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<HasPendingActionsQuery, HasPendingActionsQueryVariables>(HasPendingActionsDocument, options);\n        }\nexport function useHasPendingActionsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<HasPendingActionsQuery, HasPendingActionsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<HasPendingActionsQuery, HasPendingActionsQueryVariables>(HasPendingActionsDocument, options);\n        }\nexport type HasPendingActionsQueryHookResult = ReturnType<typeof useHasPendingActionsQuery>;\nexport type HasPendingActionsLazyQueryHookResult = ReturnType<typeof useHasPendingActionsLazyQuery>;\nexport type HasPendingActionsSuspenseQueryHookResult = ReturnType<typeof useHasPendingActionsSuspenseQuery>;\nexport type HasPendingActionsQueryResult = Apollo.QueryResult<HasPendingActionsQuery, HasPendingActionsQueryVariables>;\nexport function refetchHasPendingActionsQuery(variables: HasPendingActionsQueryVariables) {\n      return { query: HasPendingActionsDocument, variables: variables };\n    }\nexport const PlatformVersionDocument: TypedDocumentNode<PlatformVersionQuery, PlatformVersionQueryVariables> = gql`\n  query platformVersion {\n  platformVersion\n}\n    `;\n\n/**\n * __usePlatformVersionQuery__\n *\n * To run a query within a React component, call `usePlatformVersionQuery` and pass it any options that fit your needs.\n * When your component renders, `usePlatformVersionQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePlatformVersionQuery({\n *   variables: {\n *   },\n * });\n */\nexport function usePlatformVersionQuery(baseOptions?: Apollo.QueryHookOptions<PlatformVersionQuery, PlatformVersionQueryVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PlatformVersionQuery, PlatformVersionQueryVariables>(PlatformVersionDocument, options);\n      }\nexport function usePlatformVersionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PlatformVersionQuery, PlatformVersionQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PlatformVersionQuery, PlatformVersionQueryVariables>(PlatformVersionDocument, options);\n        }\nexport function usePlatformVersionSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PlatformVersionQuery, PlatformVersionQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PlatformVersionQuery, PlatformVersionQueryVariables>(PlatformVersionDocument, options);\n        }\nexport type PlatformVersionQueryHookResult = ReturnType<typeof usePlatformVersionQuery>;\nexport type PlatformVersionLazyQueryHookResult = ReturnType<typeof usePlatformVersionLazyQuery>;\nexport type PlatformVersionSuspenseQueryHookResult = ReturnType<typeof usePlatformVersionSuspenseQuery>;\nexport type PlatformVersionQueryResult = Apollo.QueryResult<PlatformVersionQuery, PlatformVersionQueryVariables>;\nexport function refetchPlatformVersionQuery(variables?: PlatformVersionQueryVariables) {\n      return { query: PlatformVersionDocument, variables: variables };\n    }\nexport const GetValuationsDocument: TypedDocumentNode<GetValuationsQuery, GetValuationsQueryVariables> = gql`\n  query getValuations($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    valuations {\n      id\n      valuation\n      date\n      round\n    }\n    valuationVisibleToShareholders\n    valuationVisibleToOptionholders\n    ownershipVisibleToShareholders\n    ownershipVisibleToOptionholders\n    currency\n  }\n}\n    `;\n\n/**\n * __useGetValuationsQuery__\n *\n * To run a query within a React component, call `useGetValuationsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetValuationsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetValuationsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetValuationsQuery(baseOptions: Apollo.QueryHookOptions<GetValuationsQuery, GetValuationsQueryVariables> & ({ variables: GetValuationsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetValuationsQuery, GetValuationsQueryVariables>(GetValuationsDocument, options);\n      }\nexport function useGetValuationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetValuationsQuery, GetValuationsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetValuationsQuery, GetValuationsQueryVariables>(GetValuationsDocument, options);\n        }\nexport function useGetValuationsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetValuationsQuery, GetValuationsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetValuationsQuery, GetValuationsQueryVariables>(GetValuationsDocument, options);\n        }\nexport type GetValuationsQueryHookResult = ReturnType<typeof useGetValuationsQuery>;\nexport type GetValuationsLazyQueryHookResult = ReturnType<typeof useGetValuationsLazyQuery>;\nexport type GetValuationsSuspenseQueryHookResult = ReturnType<typeof useGetValuationsSuspenseQuery>;\nexport type GetValuationsQueryResult = Apollo.QueryResult<GetValuationsQuery, GetValuationsQueryVariables>;\nexport function refetchGetValuationsQuery(variables: GetValuationsQueryVariables) {\n      return { query: GetValuationsDocument, variables: variables };\n    }\nexport const GetValuationDocument: TypedDocumentNode<GetValuationQuery, GetValuationQueryVariables> = gql`\n  query getValuation($organisationId: UUID!, $date: Date) {\n  organisation(organisationId: $organisationId) {\n    valuationAt(date: $date) {\n      id\n      valuation\n      date\n      round\n    }\n  }\n}\n    `;\n\n/**\n * __useGetValuationQuery__\n *\n * To run a query within a React component, call `useGetValuationQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetValuationQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetValuationQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      date: // value for 'date'\n *   },\n * });\n */\nexport function useGetValuationQuery(baseOptions: Apollo.QueryHookOptions<GetValuationQuery, GetValuationQueryVariables> & ({ variables: GetValuationQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetValuationQuery, GetValuationQueryVariables>(GetValuationDocument, options);\n      }\nexport function useGetValuationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetValuationQuery, GetValuationQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetValuationQuery, GetValuationQueryVariables>(GetValuationDocument, options);\n        }\nexport function useGetValuationSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetValuationQuery, GetValuationQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetValuationQuery, GetValuationQueryVariables>(GetValuationDocument, options);\n        }\nexport type GetValuationQueryHookResult = ReturnType<typeof useGetValuationQuery>;\nexport type GetValuationLazyQueryHookResult = ReturnType<typeof useGetValuationLazyQuery>;\nexport type GetValuationSuspenseQueryHookResult = ReturnType<typeof useGetValuationSuspenseQuery>;\nexport type GetValuationQueryResult = Apollo.QueryResult<GetValuationQuery, GetValuationQueryVariables>;\nexport function refetchGetValuationQuery(variables: GetValuationQueryVariables) {\n      return { query: GetValuationDocument, variables: variables };\n    }\nexport const AddValuationDocument: TypedDocumentNode<AddValuationMutation, AddValuationMutationVariables> = gql`\n  mutation addValuation($organisation: OrganisationCakeType!, $valuation: CakeDecimal!, $date: Date!, $round: CleanString) {\n  addValuation(\n    organisation: $organisation\n    valuation: $valuation\n    date: $date\n    round: $round\n  ) {\n    id\n    valuation\n    date\n    round\n  }\n}\n    `;\nexport type AddValuationMutationFn = Apollo.MutationFunction<AddValuationMutation, AddValuationMutationVariables>;\n\n/**\n * __useAddValuationMutation__\n *\n * To run a mutation, you first call `useAddValuationMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddValuationMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addValuationMutation, { data, loading, error }] = useAddValuationMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      valuation: // value for 'valuation'\n *      date: // value for 'date'\n *      round: // value for 'round'\n *   },\n * });\n */\nexport function useAddValuationMutation(baseOptions?: Apollo.MutationHookOptions<AddValuationMutation, AddValuationMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddValuationMutation, AddValuationMutationVariables>(AddValuationDocument, options);\n      }\nexport type AddValuationMutationHookResult = ReturnType<typeof useAddValuationMutation>;\nexport type AddValuationMutationResult = Apollo.MutationResult<AddValuationMutation>;\nexport type AddValuationMutationOptions = Apollo.BaseMutationOptions<AddValuationMutation, AddValuationMutationVariables>;\nexport const Send409aProviderNotificationDocument: TypedDocumentNode<Send409aProviderNotificationMutation, Send409aProviderNotificationMutationVariables> = gql`\n  mutation send409aProviderNotification($organisation: OrganisationCakeType!) {\n  send409aProviderNotification(organisation: $organisation)\n}\n    `;\nexport type Send409aProviderNotificationMutationFn = Apollo.MutationFunction<Send409aProviderNotificationMutation, Send409aProviderNotificationMutationVariables>;\n\n/**\n * __useSend409aProviderNotificationMutation__\n *\n * To run a mutation, you first call `useSend409aProviderNotificationMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSend409aProviderNotificationMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [send409aProviderNotificationMutation, { data, loading, error }] = useSend409aProviderNotificationMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useSend409aProviderNotificationMutation(baseOptions?: Apollo.MutationHookOptions<Send409aProviderNotificationMutation, Send409aProviderNotificationMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<Send409aProviderNotificationMutation, Send409aProviderNotificationMutationVariables>(Send409aProviderNotificationDocument, options);\n      }\nexport type Send409aProviderNotificationMutationHookResult = ReturnType<typeof useSend409aProviderNotificationMutation>;\nexport type Send409aProviderNotificationMutationResult = Apollo.MutationResult<Send409aProviderNotificationMutation>;\nexport type Send409aProviderNotificationMutationOptions = Apollo.BaseMutationOptions<Send409aProviderNotificationMutation, Send409aProviderNotificationMutationVariables>;\nexport const UpdateOneTimeAddonStatusDocument: TypedDocumentNode<UpdateOneTimeAddonStatusMutation, UpdateOneTimeAddonStatusMutationVariables> = gql`\n  mutation updateOneTimeAddonStatus($organisation: OrganisationCakeType!, $stripeId: CleanString!, $status: CleanString!) {\n  updateOneTimeAddonStatus(\n    organisation: $organisation\n    stripeId: $stripeId\n    status: $status\n  )\n}\n    `;\nexport type UpdateOneTimeAddonStatusMutationFn = Apollo.MutationFunction<UpdateOneTimeAddonStatusMutation, UpdateOneTimeAddonStatusMutationVariables>;\n\n/**\n * __useUpdateOneTimeAddonStatusMutation__\n *\n * To run a mutation, you first call `useUpdateOneTimeAddonStatusMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateOneTimeAddonStatusMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateOneTimeAddonStatusMutation, { data, loading, error }] = useUpdateOneTimeAddonStatusMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      stripeId: // value for 'stripeId'\n *      status: // value for 'status'\n *   },\n * });\n */\nexport function useUpdateOneTimeAddonStatusMutation(baseOptions?: Apollo.MutationHookOptions<UpdateOneTimeAddonStatusMutation, UpdateOneTimeAddonStatusMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateOneTimeAddonStatusMutation, UpdateOneTimeAddonStatusMutationVariables>(UpdateOneTimeAddonStatusDocument, options);\n      }\nexport type UpdateOneTimeAddonStatusMutationHookResult = ReturnType<typeof useUpdateOneTimeAddonStatusMutation>;\nexport type UpdateOneTimeAddonStatusMutationResult = Apollo.MutationResult<UpdateOneTimeAddonStatusMutation>;\nexport type UpdateOneTimeAddonStatusMutationOptions = Apollo.BaseMutationOptions<UpdateOneTimeAddonStatusMutation, UpdateOneTimeAddonStatusMutationVariables>;\nexport const DeleteValuationDocument: TypedDocumentNode<DeleteValuationMutation, DeleteValuationMutationVariables> = gql`\n  mutation deleteValuation($valuation: ValuationCakeType!) {\n  deleteValuation(valuation: $valuation) {\n    ok\n  }\n}\n    `;\nexport type DeleteValuationMutationFn = Apollo.MutationFunction<DeleteValuationMutation, DeleteValuationMutationVariables>;\n\n/**\n * __useDeleteValuationMutation__\n *\n * To run a mutation, you first call `useDeleteValuationMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteValuationMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteValuationMutation, { data, loading, error }] = useDeleteValuationMutation({\n *   variables: {\n *      valuation: // value for 'valuation'\n *   },\n * });\n */\nexport function useDeleteValuationMutation(baseOptions?: Apollo.MutationHookOptions<DeleteValuationMutation, DeleteValuationMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteValuationMutation, DeleteValuationMutationVariables>(DeleteValuationDocument, options);\n      }\nexport type DeleteValuationMutationHookResult = ReturnType<typeof useDeleteValuationMutation>;\nexport type DeleteValuationMutationResult = Apollo.MutationResult<DeleteValuationMutation>;\nexport type DeleteValuationMutationOptions = Apollo.BaseMutationOptions<DeleteValuationMutation, DeleteValuationMutationVariables>;\nexport const GetCakePlansV5Document: TypedDocumentNode<GetCakePlansV5Query, GetCakePlansV5QueryVariables> = gql`\n  query getCakePlansV5($organisation: OrganisationCakeType!, $allowDowngrade: Boolean) {\n  getCakePlansV5(organisation: $organisation, allowDowngrade: $allowDowngrade) {\n    internalId\n    price\n    isAvailable\n    currency\n    perheadPrice\n    perheadIncluded\n    availableAddons {\n      internalId\n      price\n      canBePurchased\n    }\n  }\n}\n    `;\n\n/**\n * __useGetCakePlansV5Query__\n *\n * To run a query within a React component, call `useGetCakePlansV5Query` and pass it any options that fit your needs.\n * When your component renders, `useGetCakePlansV5Query` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetCakePlansV5Query({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      allowDowngrade: // value for 'allowDowngrade'\n *   },\n * });\n */\nexport function useGetCakePlansV5Query(baseOptions: Apollo.QueryHookOptions<GetCakePlansV5Query, GetCakePlansV5QueryVariables> & ({ variables: GetCakePlansV5QueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetCakePlansV5Query, GetCakePlansV5QueryVariables>(GetCakePlansV5Document, options);\n      }\nexport function useGetCakePlansV5LazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCakePlansV5Query, GetCakePlansV5QueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetCakePlansV5Query, GetCakePlansV5QueryVariables>(GetCakePlansV5Document, options);\n        }\nexport function useGetCakePlansV5SuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetCakePlansV5Query, GetCakePlansV5QueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetCakePlansV5Query, GetCakePlansV5QueryVariables>(GetCakePlansV5Document, options);\n        }\nexport type GetCakePlansV5QueryHookResult = ReturnType<typeof useGetCakePlansV5Query>;\nexport type GetCakePlansV5LazyQueryHookResult = ReturnType<typeof useGetCakePlansV5LazyQuery>;\nexport type GetCakePlansV5SuspenseQueryHookResult = ReturnType<typeof useGetCakePlansV5SuspenseQuery>;\nexport type GetCakePlansV5QueryResult = Apollo.QueryResult<GetCakePlansV5Query, GetCakePlansV5QueryVariables>;\nexport function refetchGetCakePlansV5Query(variables: GetCakePlansV5QueryVariables) {\n      return { query: GetCakePlansV5Document, variables: variables };\n    }\nexport const GetOneTimeAddonPriceDocument: TypedDocumentNode<GetOneTimeAddonPriceQuery, GetOneTimeAddonPriceQueryVariables> = gql`\n  query getOneTimeAddonPrice($organisation: OrganisationCakeType!, $addon: CleanString!) {\n  getOneTimeAddonPrice(organisation: $organisation, cakeAddon: $addon)\n}\n    `;\n\n/**\n * __useGetOneTimeAddonPriceQuery__\n *\n * To run a query within a React component, call `useGetOneTimeAddonPriceQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOneTimeAddonPriceQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOneTimeAddonPriceQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      addon: // value for 'addon'\n *   },\n * });\n */\nexport function useGetOneTimeAddonPriceQuery(baseOptions: Apollo.QueryHookOptions<GetOneTimeAddonPriceQuery, GetOneTimeAddonPriceQueryVariables> & ({ variables: GetOneTimeAddonPriceQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOneTimeAddonPriceQuery, GetOneTimeAddonPriceQueryVariables>(GetOneTimeAddonPriceDocument, options);\n      }\nexport function useGetOneTimeAddonPriceLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOneTimeAddonPriceQuery, GetOneTimeAddonPriceQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOneTimeAddonPriceQuery, GetOneTimeAddonPriceQueryVariables>(GetOneTimeAddonPriceDocument, options);\n        }\nexport function useGetOneTimeAddonPriceSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOneTimeAddonPriceQuery, GetOneTimeAddonPriceQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOneTimeAddonPriceQuery, GetOneTimeAddonPriceQueryVariables>(GetOneTimeAddonPriceDocument, options);\n        }\nexport type GetOneTimeAddonPriceQueryHookResult = ReturnType<typeof useGetOneTimeAddonPriceQuery>;\nexport type GetOneTimeAddonPriceLazyQueryHookResult = ReturnType<typeof useGetOneTimeAddonPriceLazyQuery>;\nexport type GetOneTimeAddonPriceSuspenseQueryHookResult = ReturnType<typeof useGetOneTimeAddonPriceSuspenseQuery>;\nexport type GetOneTimeAddonPriceQueryResult = Apollo.QueryResult<GetOneTimeAddonPriceQuery, GetOneTimeAddonPriceQueryVariables>;\nexport function refetchGetOneTimeAddonPriceQuery(variables: GetOneTimeAddonPriceQueryVariables) {\n      return { query: GetOneTimeAddonPriceDocument, variables: variables };\n    }\nexport const GetOrganisationBillingDetailsDocument: TypedDocumentNode<GetOrganisationBillingDetailsQuery, GetOrganisationBillingDetailsQueryVariables> = gql`\n  query getOrganisationBillingDetails($organisationId: OrganisationCakeType!) {\n  getBillingDetails(organisation: $organisationId) {\n    ccLast4\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationBillingDetailsQuery__\n *\n * To run a query within a React component, call `useGetOrganisationBillingDetailsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationBillingDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationBillingDetailsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetOrganisationBillingDetailsQuery(baseOptions: Apollo.QueryHookOptions<GetOrganisationBillingDetailsQuery, GetOrganisationBillingDetailsQueryVariables> & ({ variables: GetOrganisationBillingDetailsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationBillingDetailsQuery, GetOrganisationBillingDetailsQueryVariables>(GetOrganisationBillingDetailsDocument, options);\n      }\nexport function useGetOrganisationBillingDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationBillingDetailsQuery, GetOrganisationBillingDetailsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationBillingDetailsQuery, GetOrganisationBillingDetailsQueryVariables>(GetOrganisationBillingDetailsDocument, options);\n        }\nexport function useGetOrganisationBillingDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationBillingDetailsQuery, GetOrganisationBillingDetailsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationBillingDetailsQuery, GetOrganisationBillingDetailsQueryVariables>(GetOrganisationBillingDetailsDocument, options);\n        }\nexport type GetOrganisationBillingDetailsQueryHookResult = ReturnType<typeof useGetOrganisationBillingDetailsQuery>;\nexport type GetOrganisationBillingDetailsLazyQueryHookResult = ReturnType<typeof useGetOrganisationBillingDetailsLazyQuery>;\nexport type GetOrganisationBillingDetailsSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationBillingDetailsSuspenseQuery>;\nexport type GetOrganisationBillingDetailsQueryResult = Apollo.QueryResult<GetOrganisationBillingDetailsQuery, GetOrganisationBillingDetailsQueryVariables>;\nexport function refetchGetOrganisationBillingDetailsQuery(variables: GetOrganisationBillingDetailsQueryVariables) {\n      return { query: GetOrganisationBillingDetailsDocument, variables: variables };\n    }\nexport const GetCouponDataDocument: TypedDocumentNode<GetCouponDataQuery, GetCouponDataQueryVariables> = gql`\n  query getCouponData($coupon: CleanString!) {\n  getCouponData(coupon: $coupon) {\n    isPercentage\n    value\n    durationInMonths\n    duration\n  }\n}\n    `;\n\n/**\n * __useGetCouponDataQuery__\n *\n * To run a query within a React component, call `useGetCouponDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetCouponDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetCouponDataQuery({\n *   variables: {\n *      coupon: // value for 'coupon'\n *   },\n * });\n */\nexport function useGetCouponDataQuery(baseOptions: Apollo.QueryHookOptions<GetCouponDataQuery, GetCouponDataQueryVariables> & ({ variables: GetCouponDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetCouponDataQuery, GetCouponDataQueryVariables>(GetCouponDataDocument, options);\n      }\nexport function useGetCouponDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCouponDataQuery, GetCouponDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetCouponDataQuery, GetCouponDataQueryVariables>(GetCouponDataDocument, options);\n        }\nexport function useGetCouponDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetCouponDataQuery, GetCouponDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetCouponDataQuery, GetCouponDataQueryVariables>(GetCouponDataDocument, options);\n        }\nexport type GetCouponDataQueryHookResult = ReturnType<typeof useGetCouponDataQuery>;\nexport type GetCouponDataLazyQueryHookResult = ReturnType<typeof useGetCouponDataLazyQuery>;\nexport type GetCouponDataSuspenseQueryHookResult = ReturnType<typeof useGetCouponDataSuspenseQuery>;\nexport type GetCouponDataQueryResult = Apollo.QueryResult<GetCouponDataQuery, GetCouponDataQueryVariables>;\nexport function refetchGetCouponDataQuery(variables: GetCouponDataQueryVariables) {\n      return { query: GetCouponDataDocument, variables: variables };\n    }\nexport const UpgradeSubscriptionDocument: TypedDocumentNode<UpgradeSubscriptionMutation, UpgradeSubscriptionMutationVariables> = gql`\n  mutation upgradeSubscription($organisationId: OrganisationCakeType!, $targetPlanId: String!, $stripeCoupon: CleanString, $stripePaymentId: String, $addons: [String!]) {\n  upgradeSubscription(\n    organisation: $organisationId\n    targetPlanId: $targetPlanId\n    stripeCoupon: $stripeCoupon\n    stripePaymentId: $stripePaymentId\n    addons: $addons\n  ) {\n    ok\n    previousPlan\n    targetPlan\n  }\n}\n    `;\nexport type UpgradeSubscriptionMutationFn = Apollo.MutationFunction<UpgradeSubscriptionMutation, UpgradeSubscriptionMutationVariables>;\n\n/**\n * __useUpgradeSubscriptionMutation__\n *\n * To run a mutation, you first call `useUpgradeSubscriptionMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpgradeSubscriptionMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [upgradeSubscriptionMutation, { data, loading, error }] = useUpgradeSubscriptionMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      targetPlanId: // value for 'targetPlanId'\n *      stripeCoupon: // value for 'stripeCoupon'\n *      stripePaymentId: // value for 'stripePaymentId'\n *      addons: // value for 'addons'\n *   },\n * });\n */\nexport function useUpgradeSubscriptionMutation(baseOptions?: Apollo.MutationHookOptions<UpgradeSubscriptionMutation, UpgradeSubscriptionMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpgradeSubscriptionMutation, UpgradeSubscriptionMutationVariables>(UpgradeSubscriptionDocument, options);\n      }\nexport type UpgradeSubscriptionMutationHookResult = ReturnType<typeof useUpgradeSubscriptionMutation>;\nexport type UpgradeSubscriptionMutationResult = Apollo.MutationResult<UpgradeSubscriptionMutation>;\nexport type UpgradeSubscriptionMutationOptions = Apollo.BaseMutationOptions<UpgradeSubscriptionMutation, UpgradeSubscriptionMutationVariables>;\nexport const BuyOneOff409ADocument: TypedDocumentNode<BuyOneOff409AMutation, BuyOneOff409AMutationVariables> = gql`\n  mutation buyOneOff409A($organisationId: OrganisationCakeType!) {\n  buyOneOff409A(organisation: $organisationId)\n}\n    `;\nexport type BuyOneOff409AMutationFn = Apollo.MutationFunction<BuyOneOff409AMutation, BuyOneOff409AMutationVariables>;\n\n/**\n * __useBuyOneOff409AMutation__\n *\n * To run a mutation, you first call `useBuyOneOff409AMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useBuyOneOff409AMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [buyOneOff409AMutation, { data, loading, error }] = useBuyOneOff409AMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useBuyOneOff409AMutation(baseOptions?: Apollo.MutationHookOptions<BuyOneOff409AMutation, BuyOneOff409AMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<BuyOneOff409AMutation, BuyOneOff409AMutationVariables>(BuyOneOff409ADocument, options);\n      }\nexport type BuyOneOff409AMutationHookResult = ReturnType<typeof useBuyOneOff409AMutation>;\nexport type BuyOneOff409AMutationResult = Apollo.MutationResult<BuyOneOff409AMutation>;\nexport type BuyOneOff409AMutationOptions = Apollo.BaseMutationOptions<BuyOneOff409AMutation, BuyOneOff409AMutationVariables>;\nexport const UpdateCreditCardDocument: TypedDocumentNode<UpdateCreditCardMutation, UpdateCreditCardMutationVariables> = gql`\n  mutation updateCreditCard($organisationId: OrganisationCakeType!, $stripeId: CleanString!) {\n  updateCreditCard(organisation: $organisationId, stripeId: $stripeId) {\n    payCount\n    pendingInvoiceIds\n  }\n}\n    `;\nexport type UpdateCreditCardMutationFn = Apollo.MutationFunction<UpdateCreditCardMutation, UpdateCreditCardMutationVariables>;\n\n/**\n * __useUpdateCreditCardMutation__\n *\n * To run a mutation, you first call `useUpdateCreditCardMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateCreditCardMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateCreditCardMutation, { data, loading, error }] = useUpdateCreditCardMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      stripeId: // value for 'stripeId'\n *   },\n * });\n */\nexport function useUpdateCreditCardMutation(baseOptions?: Apollo.MutationHookOptions<UpdateCreditCardMutation, UpdateCreditCardMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateCreditCardMutation, UpdateCreditCardMutationVariables>(UpdateCreditCardDocument, options);\n      }\nexport type UpdateCreditCardMutationHookResult = ReturnType<typeof useUpdateCreditCardMutation>;\nexport type UpdateCreditCardMutationResult = Apollo.MutationResult<UpdateCreditCardMutation>;\nexport type UpdateCreditCardMutationOptions = Apollo.BaseMutationOptions<UpdateCreditCardMutation, UpdateCreditCardMutationVariables>;\nexport const PayPendingInvoicesDocument: TypedDocumentNode<PayPendingInvoicesMutation, PayPendingInvoicesMutationVariables> = gql`\n  mutation payPendingInvoices($organisationId: OrganisationCakeType!) {\n  payPendingInvoices(organisation: $organisationId) {\n    payCount\n    pendingInvoiceIds\n  }\n}\n    `;\nexport type PayPendingInvoicesMutationFn = Apollo.MutationFunction<PayPendingInvoicesMutation, PayPendingInvoicesMutationVariables>;\n\n/**\n * __usePayPendingInvoicesMutation__\n *\n * To run a mutation, you first call `usePayPendingInvoicesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `usePayPendingInvoicesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [payPendingInvoicesMutation, { data, loading, error }] = usePayPendingInvoicesMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function usePayPendingInvoicesMutation(baseOptions?: Apollo.MutationHookOptions<PayPendingInvoicesMutation, PayPendingInvoicesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<PayPendingInvoicesMutation, PayPendingInvoicesMutationVariables>(PayPendingInvoicesDocument, options);\n      }\nexport type PayPendingInvoicesMutationHookResult = ReturnType<typeof usePayPendingInvoicesMutation>;\nexport type PayPendingInvoicesMutationResult = Apollo.MutationResult<PayPendingInvoicesMutation>;\nexport type PayPendingInvoicesMutationOptions = Apollo.BaseMutationOptions<PayPendingInvoicesMutation, PayPendingInvoicesMutationVariables>;\nexport const GetBillingAvatarDocument: TypedDocumentNode<GetBillingAvatarQuery, GetBillingAvatarQueryVariables> = gql`\n  query getBillingAvatar($organisationId: OrganisationCakeType!) {\n  getBillingAvatar(organisation: $organisationId) {\n    name\n    picture\n  }\n}\n    `;\n\n/**\n * __useGetBillingAvatarQuery__\n *\n * To run a query within a React component, call `useGetBillingAvatarQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetBillingAvatarQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetBillingAvatarQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetBillingAvatarQuery(baseOptions: Apollo.QueryHookOptions<GetBillingAvatarQuery, GetBillingAvatarQueryVariables> & ({ variables: GetBillingAvatarQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetBillingAvatarQuery, GetBillingAvatarQueryVariables>(GetBillingAvatarDocument, options);\n      }\nexport function useGetBillingAvatarLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetBillingAvatarQuery, GetBillingAvatarQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetBillingAvatarQuery, GetBillingAvatarQueryVariables>(GetBillingAvatarDocument, options);\n        }\nexport function useGetBillingAvatarSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetBillingAvatarQuery, GetBillingAvatarQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetBillingAvatarQuery, GetBillingAvatarQueryVariables>(GetBillingAvatarDocument, options);\n        }\nexport type GetBillingAvatarQueryHookResult = ReturnType<typeof useGetBillingAvatarQuery>;\nexport type GetBillingAvatarLazyQueryHookResult = ReturnType<typeof useGetBillingAvatarLazyQuery>;\nexport type GetBillingAvatarSuspenseQueryHookResult = ReturnType<typeof useGetBillingAvatarSuspenseQuery>;\nexport type GetBillingAvatarQueryResult = Apollo.QueryResult<GetBillingAvatarQuery, GetBillingAvatarQueryVariables>;\nexport function refetchGetBillingAvatarQuery(variables: GetBillingAvatarQueryVariables) {\n      return { query: GetBillingAvatarDocument, variables: variables };\n    }\nexport const UpdateBillingContactDocument: TypedDocumentNode<UpdateBillingContactMutation, UpdateBillingContactMutationVariables> = gql`\n  mutation updateBillingContact($organisationId: OrganisationCakeType!, $email: CleanString!, $mobile: CleanString) {\n  updateBillingContact(\n    organisation: $organisationId\n    email: $email\n    mobile: $mobile\n  )\n}\n    `;\nexport type UpdateBillingContactMutationFn = Apollo.MutationFunction<UpdateBillingContactMutation, UpdateBillingContactMutationVariables>;\n\n/**\n * __useUpdateBillingContactMutation__\n *\n * To run a mutation, you first call `useUpdateBillingContactMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateBillingContactMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateBillingContactMutation, { data, loading, error }] = useUpdateBillingContactMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      email: // value for 'email'\n *      mobile: // value for 'mobile'\n *   },\n * });\n */\nexport function useUpdateBillingContactMutation(baseOptions?: Apollo.MutationHookOptions<UpdateBillingContactMutation, UpdateBillingContactMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateBillingContactMutation, UpdateBillingContactMutationVariables>(UpdateBillingContactDocument, options);\n      }\nexport type UpdateBillingContactMutationHookResult = ReturnType<typeof useUpdateBillingContactMutation>;\nexport type UpdateBillingContactMutationResult = Apollo.MutationResult<UpdateBillingContactMutation>;\nexport type UpdateBillingContactMutationOptions = Apollo.BaseMutationOptions<UpdateBillingContactMutation, UpdateBillingContactMutationVariables>;\nexport const PauseSubscriptionDocument: TypedDocumentNode<PauseSubscriptionMutation, PauseSubscriptionMutationVariables> = gql`\n  mutation pauseSubscription($organisation: OrganisationCakeType!, $pause: Boolean!, $reasonForPause: String) {\n  pauseSubscription(\n    organisation: $organisation\n    pause: $pause\n    reasonForPause: $reasonForPause\n  )\n}\n    `;\nexport type PauseSubscriptionMutationFn = Apollo.MutationFunction<PauseSubscriptionMutation, PauseSubscriptionMutationVariables>;\n\n/**\n * __usePauseSubscriptionMutation__\n *\n * To run a mutation, you first call `usePauseSubscriptionMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `usePauseSubscriptionMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [pauseSubscriptionMutation, { data, loading, error }] = usePauseSubscriptionMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      pause: // value for 'pause'\n *      reasonForPause: // value for 'reasonForPause'\n *   },\n * });\n */\nexport function usePauseSubscriptionMutation(baseOptions?: Apollo.MutationHookOptions<PauseSubscriptionMutation, PauseSubscriptionMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<PauseSubscriptionMutation, PauseSubscriptionMutationVariables>(PauseSubscriptionDocument, options);\n      }\nexport type PauseSubscriptionMutationHookResult = ReturnType<typeof usePauseSubscriptionMutation>;\nexport type PauseSubscriptionMutationResult = Apollo.MutationResult<PauseSubscriptionMutation>;\nexport type PauseSubscriptionMutationOptions = Apollo.BaseMutationOptions<PauseSubscriptionMutation, PauseSubscriptionMutationVariables>;\nexport const RequestCancelSubscriptionDocument: TypedDocumentNode<RequestCancelSubscriptionMutation, RequestCancelSubscriptionMutationVariables> = gql`\n  mutation requestCancelSubscription($organisation: OrganisationCakeType!, $reason: CleanString!, $competitorName: String, $feedback: String) {\n  requestCancelSubscription(\n    organisation: $organisation\n    reason: $reason\n    competitorName: $competitorName\n    feedback: $feedback\n  )\n}\n    `;\nexport type RequestCancelSubscriptionMutationFn = Apollo.MutationFunction<RequestCancelSubscriptionMutation, RequestCancelSubscriptionMutationVariables>;\n\n/**\n * __useRequestCancelSubscriptionMutation__\n *\n * To run a mutation, you first call `useRequestCancelSubscriptionMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRequestCancelSubscriptionMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [requestCancelSubscriptionMutation, { data, loading, error }] = useRequestCancelSubscriptionMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      reason: // value for 'reason'\n *      competitorName: // value for 'competitorName'\n *      feedback: // value for 'feedback'\n *   },\n * });\n */\nexport function useRequestCancelSubscriptionMutation(baseOptions?: Apollo.MutationHookOptions<RequestCancelSubscriptionMutation, RequestCancelSubscriptionMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RequestCancelSubscriptionMutation, RequestCancelSubscriptionMutationVariables>(RequestCancelSubscriptionDocument, options);\n      }\nexport type RequestCancelSubscriptionMutationHookResult = ReturnType<typeof useRequestCancelSubscriptionMutation>;\nexport type RequestCancelSubscriptionMutationResult = Apollo.MutationResult<RequestCancelSubscriptionMutation>;\nexport type RequestCancelSubscriptionMutationOptions = Apollo.BaseMutationOptions<RequestCancelSubscriptionMutation, RequestCancelSubscriptionMutationVariables>;\nexport const GetStripeCustomerIdDocument: TypedDocumentNode<GetStripeCustomerIdQuery, GetStripeCustomerIdQueryVariables> = gql`\n  query getStripeCustomerId($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    stripeCustomerId\n  }\n}\n    `;\n\n/**\n * __useGetStripeCustomerIdQuery__\n *\n * To run a query within a React component, call `useGetStripeCustomerIdQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetStripeCustomerIdQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetStripeCustomerIdQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetStripeCustomerIdQuery(baseOptions: Apollo.QueryHookOptions<GetStripeCustomerIdQuery, GetStripeCustomerIdQueryVariables> & ({ variables: GetStripeCustomerIdQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetStripeCustomerIdQuery, GetStripeCustomerIdQueryVariables>(GetStripeCustomerIdDocument, options);\n      }\nexport function useGetStripeCustomerIdLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetStripeCustomerIdQuery, GetStripeCustomerIdQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetStripeCustomerIdQuery, GetStripeCustomerIdQueryVariables>(GetStripeCustomerIdDocument, options);\n        }\nexport function useGetStripeCustomerIdSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetStripeCustomerIdQuery, GetStripeCustomerIdQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetStripeCustomerIdQuery, GetStripeCustomerIdQueryVariables>(GetStripeCustomerIdDocument, options);\n        }\nexport type GetStripeCustomerIdQueryHookResult = ReturnType<typeof useGetStripeCustomerIdQuery>;\nexport type GetStripeCustomerIdLazyQueryHookResult = ReturnType<typeof useGetStripeCustomerIdLazyQuery>;\nexport type GetStripeCustomerIdSuspenseQueryHookResult = ReturnType<typeof useGetStripeCustomerIdSuspenseQuery>;\nexport type GetStripeCustomerIdQueryResult = Apollo.QueryResult<GetStripeCustomerIdQuery, GetStripeCustomerIdQueryVariables>;\nexport function refetchGetStripeCustomerIdQuery(variables: GetStripeCustomerIdQueryVariables) {\n      return { query: GetStripeCustomerIdDocument, variables: variables };\n    }\nexport const UnusedTimeDocument: TypedDocumentNode<UnusedTimeQuery, UnusedTimeQueryVariables> = gql`\n  query unusedTime($organisation: OrganisationCakeType!) {\n  unusedTime(organisation: $organisation)\n}\n    `;\n\n/**\n * __useUnusedTimeQuery__\n *\n * To run a query within a React component, call `useUnusedTimeQuery` and pass it any options that fit your needs.\n * When your component renders, `useUnusedTimeQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useUnusedTimeQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useUnusedTimeQuery(baseOptions: Apollo.QueryHookOptions<UnusedTimeQuery, UnusedTimeQueryVariables> & ({ variables: UnusedTimeQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<UnusedTimeQuery, UnusedTimeQueryVariables>(UnusedTimeDocument, options);\n      }\nexport function useUnusedTimeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UnusedTimeQuery, UnusedTimeQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<UnusedTimeQuery, UnusedTimeQueryVariables>(UnusedTimeDocument, options);\n        }\nexport function useUnusedTimeSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UnusedTimeQuery, UnusedTimeQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<UnusedTimeQuery, UnusedTimeQueryVariables>(UnusedTimeDocument, options);\n        }\nexport type UnusedTimeQueryHookResult = ReturnType<typeof useUnusedTimeQuery>;\nexport type UnusedTimeLazyQueryHookResult = ReturnType<typeof useUnusedTimeLazyQuery>;\nexport type UnusedTimeSuspenseQueryHookResult = ReturnType<typeof useUnusedTimeSuspenseQuery>;\nexport type UnusedTimeQueryResult = Apollo.QueryResult<UnusedTimeQuery, UnusedTimeQueryVariables>;\nexport function refetchUnusedTimeQuery(variables: UnusedTimeQueryVariables) {\n      return { query: UnusedTimeDocument, variables: variables };\n    }\nexport const UpdateVisibilitySettingsDocument: TypedDocumentNode<UpdateVisibilitySettingsMutation, UpdateVisibilitySettingsMutationVariables> = gql`\n  mutation updateVisibilitySettings($organisation: OrganisationCakeType!, $valuationVisibleToShareholders: Boolean!, $valuationVisibleToOptionholders: Boolean!, $ownershipVisibleToShareholders: Boolean!, $ownershipVisibleToOptionholders: Boolean!) {\n  updateVisibilitySettings(\n    organisation: $organisation\n    valuationVisibleToShareholders: $valuationVisibleToShareholders\n    valuationVisibleToOptionholders: $valuationVisibleToOptionholders\n    ownershipVisibleToShareholders: $ownershipVisibleToShareholders\n    ownershipVisibleToOptionholders: $ownershipVisibleToOptionholders\n  )\n}\n    `;\nexport type UpdateVisibilitySettingsMutationFn = Apollo.MutationFunction<UpdateVisibilitySettingsMutation, UpdateVisibilitySettingsMutationVariables>;\n\n/**\n * __useUpdateVisibilitySettingsMutation__\n *\n * To run a mutation, you first call `useUpdateVisibilitySettingsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateVisibilitySettingsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateVisibilitySettingsMutation, { data, loading, error }] = useUpdateVisibilitySettingsMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      valuationVisibleToShareholders: // value for 'valuationVisibleToShareholders'\n *      valuationVisibleToOptionholders: // value for 'valuationVisibleToOptionholders'\n *      ownershipVisibleToShareholders: // value for 'ownershipVisibleToShareholders'\n *      ownershipVisibleToOptionholders: // value for 'ownershipVisibleToOptionholders'\n *   },\n * });\n */\nexport function useUpdateVisibilitySettingsMutation(baseOptions?: Apollo.MutationHookOptions<UpdateVisibilitySettingsMutation, UpdateVisibilitySettingsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateVisibilitySettingsMutation, UpdateVisibilitySettingsMutationVariables>(UpdateVisibilitySettingsDocument, options);\n      }\nexport type UpdateVisibilitySettingsMutationHookResult = ReturnType<typeof useUpdateVisibilitySettingsMutation>;\nexport type UpdateVisibilitySettingsMutationResult = Apollo.MutationResult<UpdateVisibilitySettingsMutation>;\nexport type UpdateVisibilitySettingsMutationOptions = Apollo.BaseMutationOptions<UpdateVisibilitySettingsMutation, UpdateVisibilitySettingsMutationVariables>;\nexport const ResetUserMfaEnrollDocument: TypedDocumentNode<ResetUserMfaEnrollMutation, ResetUserMfaEnrollMutationVariables> = gql`\n  mutation resetUserMfaEnroll($organisation: OrganisationCakeType!, $userId: UUID!) {\n  resetUserMfaEnroll(organisation: $organisation, userId: $userId)\n}\n    `;\nexport type ResetUserMfaEnrollMutationFn = Apollo.MutationFunction<ResetUserMfaEnrollMutation, ResetUserMfaEnrollMutationVariables>;\n\n/**\n * __useResetUserMfaEnrollMutation__\n *\n * To run a mutation, you first call `useResetUserMfaEnrollMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useResetUserMfaEnrollMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [resetUserMfaEnrollMutation, { data, loading, error }] = useResetUserMfaEnrollMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      userId: // value for 'userId'\n *   },\n * });\n */\nexport function useResetUserMfaEnrollMutation(baseOptions?: Apollo.MutationHookOptions<ResetUserMfaEnrollMutation, ResetUserMfaEnrollMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ResetUserMfaEnrollMutation, ResetUserMfaEnrollMutationVariables>(ResetUserMfaEnrollDocument, options);\n      }\nexport type ResetUserMfaEnrollMutationHookResult = ReturnType<typeof useResetUserMfaEnrollMutation>;\nexport type ResetUserMfaEnrollMutationResult = Apollo.MutationResult<ResetUserMfaEnrollMutation>;\nexport type ResetUserMfaEnrollMutationOptions = Apollo.BaseMutationOptions<ResetUserMfaEnrollMutation, ResetUserMfaEnrollMutationVariables>;\nexport const WhitelistUserMfaDocument: TypedDocumentNode<WhitelistUserMfaMutation, WhitelistUserMfaMutationVariables> = gql`\n  mutation whitelistUserMfa($organisation: OrganisationCakeType!, $userId: UUID!) {\n  whitelistUserMfa(organisation: $organisation, userId: $userId)\n}\n    `;\nexport type WhitelistUserMfaMutationFn = Apollo.MutationFunction<WhitelistUserMfaMutation, WhitelistUserMfaMutationVariables>;\n\n/**\n * __useWhitelistUserMfaMutation__\n *\n * To run a mutation, you first call `useWhitelistUserMfaMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useWhitelistUserMfaMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [whitelistUserMfaMutation, { data, loading, error }] = useWhitelistUserMfaMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      userId: // value for 'userId'\n *   },\n * });\n */\nexport function useWhitelistUserMfaMutation(baseOptions?: Apollo.MutationHookOptions<WhitelistUserMfaMutation, WhitelistUserMfaMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<WhitelistUserMfaMutation, WhitelistUserMfaMutationVariables>(WhitelistUserMfaDocument, options);\n      }\nexport type WhitelistUserMfaMutationHookResult = ReturnType<typeof useWhitelistUserMfaMutation>;\nexport type WhitelistUserMfaMutationResult = Apollo.MutationResult<WhitelistUserMfaMutation>;\nexport type WhitelistUserMfaMutationOptions = Apollo.BaseMutationOptions<WhitelistUserMfaMutation, WhitelistUserMfaMutationVariables>;\nexport const ToggleMfaRequiredDocument: TypedDocumentNode<ToggleMfaRequiredMutation, ToggleMfaRequiredMutationVariables> = gql`\n  mutation toggleMfaRequired($organisation: OrganisationCakeType!, $required: Boolean!, $otpCode: CleanString) {\n  toggleMfaRequired(\n    organisation: $organisation\n    required: $required\n    otpCode: $otpCode\n  ) {\n    required\n    mfaSetupNeeded {\n      configUrl\n      qrcodeImage\n    }\n  }\n}\n    `;\nexport type ToggleMfaRequiredMutationFn = Apollo.MutationFunction<ToggleMfaRequiredMutation, ToggleMfaRequiredMutationVariables>;\n\n/**\n * __useToggleMfaRequiredMutation__\n *\n * To run a mutation, you first call `useToggleMfaRequiredMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useToggleMfaRequiredMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [toggleMfaRequiredMutation, { data, loading, error }] = useToggleMfaRequiredMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      required: // value for 'required'\n *      otpCode: // value for 'otpCode'\n *   },\n * });\n */\nexport function useToggleMfaRequiredMutation(baseOptions?: Apollo.MutationHookOptions<ToggleMfaRequiredMutation, ToggleMfaRequiredMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ToggleMfaRequiredMutation, ToggleMfaRequiredMutationVariables>(ToggleMfaRequiredDocument, options);\n      }\nexport type ToggleMfaRequiredMutationHookResult = ReturnType<typeof useToggleMfaRequiredMutation>;\nexport type ToggleMfaRequiredMutationResult = Apollo.MutationResult<ToggleMfaRequiredMutation>;\nexport type ToggleMfaRequiredMutationOptions = Apollo.BaseMutationOptions<ToggleMfaRequiredMutation, ToggleMfaRequiredMutationVariables>;\nexport const OrganisationMfaStatusDocument: TypedDocumentNode<OrganisationMfaStatusQuery, OrganisationMfaStatusQueryVariables> = gql`\n  query organisationMfaStatus($organisationId: UUID!) {\n  organisationMfaStatus(organisationId: $organisationId)\n}\n    `;\n\n/**\n * __useOrganisationMfaStatusQuery__\n *\n * To run a query within a React component, call `useOrganisationMfaStatusQuery` and pass it any options that fit your needs.\n * When your component renders, `useOrganisationMfaStatusQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOrganisationMfaStatusQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useOrganisationMfaStatusQuery(baseOptions: Apollo.QueryHookOptions<OrganisationMfaStatusQuery, OrganisationMfaStatusQueryVariables> & ({ variables: OrganisationMfaStatusQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OrganisationMfaStatusQuery, OrganisationMfaStatusQueryVariables>(OrganisationMfaStatusDocument, options);\n      }\nexport function useOrganisationMfaStatusLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OrganisationMfaStatusQuery, OrganisationMfaStatusQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OrganisationMfaStatusQuery, OrganisationMfaStatusQueryVariables>(OrganisationMfaStatusDocument, options);\n        }\nexport function useOrganisationMfaStatusSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OrganisationMfaStatusQuery, OrganisationMfaStatusQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OrganisationMfaStatusQuery, OrganisationMfaStatusQueryVariables>(OrganisationMfaStatusDocument, options);\n        }\nexport type OrganisationMfaStatusQueryHookResult = ReturnType<typeof useOrganisationMfaStatusQuery>;\nexport type OrganisationMfaStatusLazyQueryHookResult = ReturnType<typeof useOrganisationMfaStatusLazyQuery>;\nexport type OrganisationMfaStatusSuspenseQueryHookResult = ReturnType<typeof useOrganisationMfaStatusSuspenseQuery>;\nexport type OrganisationMfaStatusQueryResult = Apollo.QueryResult<OrganisationMfaStatusQuery, OrganisationMfaStatusQueryVariables>;\nexport function refetchOrganisationMfaStatusQuery(variables: OrganisationMfaStatusQueryVariables) {\n      return { query: OrganisationMfaStatusDocument, variables: variables };\n    }\nexport const GetUsersWithMfaDocument: TypedDocumentNode<GetUsersWithMfaQuery, GetUsersWithMfaQueryVariables> = gql`\n  query getUsersWithMfa($organisation: OrganisationCakeType, $page: Int!, $itemsPerPage: Int) {\n  usersWithMfa(\n    organisation: $organisation\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    currentPage\n    count\n    pageData {\n      hasEnrolledMfa\n      email\n      firstName\n      lastName\n      picture\n      id\n      mfaWhitelist\n    }\n  }\n}\n    `;\n\n/**\n * __useGetUsersWithMfaQuery__\n *\n * To run a query within a React component, call `useGetUsersWithMfaQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetUsersWithMfaQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetUsersWithMfaQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetUsersWithMfaQuery(baseOptions: Apollo.QueryHookOptions<GetUsersWithMfaQuery, GetUsersWithMfaQueryVariables> & ({ variables: GetUsersWithMfaQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetUsersWithMfaQuery, GetUsersWithMfaQueryVariables>(GetUsersWithMfaDocument, options);\n      }\nexport function useGetUsersWithMfaLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUsersWithMfaQuery, GetUsersWithMfaQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetUsersWithMfaQuery, GetUsersWithMfaQueryVariables>(GetUsersWithMfaDocument, options);\n        }\nexport function useGetUsersWithMfaSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetUsersWithMfaQuery, GetUsersWithMfaQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetUsersWithMfaQuery, GetUsersWithMfaQueryVariables>(GetUsersWithMfaDocument, options);\n        }\nexport type GetUsersWithMfaQueryHookResult = ReturnType<typeof useGetUsersWithMfaQuery>;\nexport type GetUsersWithMfaLazyQueryHookResult = ReturnType<typeof useGetUsersWithMfaLazyQuery>;\nexport type GetUsersWithMfaSuspenseQueryHookResult = ReturnType<typeof useGetUsersWithMfaSuspenseQuery>;\nexport type GetUsersWithMfaQueryResult = Apollo.QueryResult<GetUsersWithMfaQuery, GetUsersWithMfaQueryVariables>;\nexport function refetchGetUsersWithMfaQuery(variables: GetUsersWithMfaQueryVariables) {\n      return { query: GetUsersWithMfaDocument, variables: variables };\n    }\nexport const SendRequest409aCallbackDocument: TypedDocumentNode<SendRequest409aCallbackMutation, SendRequest409aCallbackMutationVariables> = gql`\n  mutation sendRequest409aCallback($organisation: OrganisationCakeType!, $mobileNumber: String!) {\n  sendRequest409aCallback(\n    organisation: $organisation\n    mobileNumber: $mobileNumber\n  )\n}\n    `;\nexport type SendRequest409aCallbackMutationFn = Apollo.MutationFunction<SendRequest409aCallbackMutation, SendRequest409aCallbackMutationVariables>;\n\n/**\n * __useSendRequest409aCallbackMutation__\n *\n * To run a mutation, you first call `useSendRequest409aCallbackMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSendRequest409aCallbackMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [sendRequest409aCallbackMutation, { data, loading, error }] = useSendRequest409aCallbackMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      mobileNumber: // value for 'mobileNumber'\n *   },\n * });\n */\nexport function useSendRequest409aCallbackMutation(baseOptions?: Apollo.MutationHookOptions<SendRequest409aCallbackMutation, SendRequest409aCallbackMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SendRequest409aCallbackMutation, SendRequest409aCallbackMutationVariables>(SendRequest409aCallbackDocument, options);\n      }\nexport type SendRequest409aCallbackMutationHookResult = ReturnType<typeof useSendRequest409aCallbackMutation>;\nexport type SendRequest409aCallbackMutationResult = Apollo.MutationResult<SendRequest409aCallbackMutation>;\nexport type SendRequest409aCallbackMutationOptions = Apollo.BaseMutationOptions<SendRequest409aCallbackMutation, SendRequest409aCallbackMutationVariables>;\nexport const SendActivityLogFeedbackDocument: TypedDocumentNode<SendActivityLogFeedbackMutation, SendActivityLogFeedbackMutationVariables> = gql`\n  mutation sendActivityLogFeedback($organisation: OrganisationCakeType!, $activityLogFeedback: CleanString!) {\n  sendActivityLogFeedback(\n    organisation: $organisation\n    activityLogFeedback: $activityLogFeedback\n  )\n}\n    `;\nexport type SendActivityLogFeedbackMutationFn = Apollo.MutationFunction<SendActivityLogFeedbackMutation, SendActivityLogFeedbackMutationVariables>;\n\n/**\n * __useSendActivityLogFeedbackMutation__\n *\n * To run a mutation, you first call `useSendActivityLogFeedbackMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSendActivityLogFeedbackMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [sendActivityLogFeedbackMutation, { data, loading, error }] = useSendActivityLogFeedbackMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      activityLogFeedback: // value for 'activityLogFeedback'\n *   },\n * });\n */\nexport function useSendActivityLogFeedbackMutation(baseOptions?: Apollo.MutationHookOptions<SendActivityLogFeedbackMutation, SendActivityLogFeedbackMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SendActivityLogFeedbackMutation, SendActivityLogFeedbackMutationVariables>(SendActivityLogFeedbackDocument, options);\n      }\nexport type SendActivityLogFeedbackMutationHookResult = ReturnType<typeof useSendActivityLogFeedbackMutation>;\nexport type SendActivityLogFeedbackMutationResult = Apollo.MutationResult<SendActivityLogFeedbackMutation>;\nexport type SendActivityLogFeedbackMutationOptions = Apollo.BaseMutationOptions<SendActivityLogFeedbackMutation, SendActivityLogFeedbackMutationVariables>;\nexport const SaveShareCertificateDisclaimerDocument: TypedDocumentNode<SaveShareCertificateDisclaimerMutation, SaveShareCertificateDisclaimerMutationVariables> = gql`\n  mutation saveShareCertificateDisclaimer($organisation: OrganisationCakeType!, $name: CleanString!, $disclaimerText: CleanString!, $disclaimer: ShareCertificateDisclaimerCakeType, $sharetypeDefault: SharetypeCakeType) {\n  saveShareCertificateDisclaimer(\n    organisation: $organisation\n    name: $name\n    disclaimerText: $disclaimerText\n    disclaimer: $disclaimer\n    sharetypeDefault: $sharetypeDefault\n  )\n}\n    `;\nexport type SaveShareCertificateDisclaimerMutationFn = Apollo.MutationFunction<SaveShareCertificateDisclaimerMutation, SaveShareCertificateDisclaimerMutationVariables>;\n\n/**\n * __useSaveShareCertificateDisclaimerMutation__\n *\n * To run a mutation, you first call `useSaveShareCertificateDisclaimerMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSaveShareCertificateDisclaimerMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [saveShareCertificateDisclaimerMutation, { data, loading, error }] = useSaveShareCertificateDisclaimerMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      name: // value for 'name'\n *      disclaimerText: // value for 'disclaimerText'\n *      disclaimer: // value for 'disclaimer'\n *      sharetypeDefault: // value for 'sharetypeDefault'\n *   },\n * });\n */\nexport function useSaveShareCertificateDisclaimerMutation(baseOptions?: Apollo.MutationHookOptions<SaveShareCertificateDisclaimerMutation, SaveShareCertificateDisclaimerMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SaveShareCertificateDisclaimerMutation, SaveShareCertificateDisclaimerMutationVariables>(SaveShareCertificateDisclaimerDocument, options);\n      }\nexport type SaveShareCertificateDisclaimerMutationHookResult = ReturnType<typeof useSaveShareCertificateDisclaimerMutation>;\nexport type SaveShareCertificateDisclaimerMutationResult = Apollo.MutationResult<SaveShareCertificateDisclaimerMutation>;\nexport type SaveShareCertificateDisclaimerMutationOptions = Apollo.BaseMutationOptions<SaveShareCertificateDisclaimerMutation, SaveShareCertificateDisclaimerMutationVariables>;\nexport const DeleteShareCertificateDisclaimerDocument: TypedDocumentNode<DeleteShareCertificateDisclaimerMutation, DeleteShareCertificateDisclaimerMutationVariables> = gql`\n  mutation deleteShareCertificateDisclaimer($disclaimer: ShareCertificateDisclaimerCakeType!) {\n  deleteShareCertificateDisclaimer(disclaimer: $disclaimer)\n}\n    `;\nexport type DeleteShareCertificateDisclaimerMutationFn = Apollo.MutationFunction<DeleteShareCertificateDisclaimerMutation, DeleteShareCertificateDisclaimerMutationVariables>;\n\n/**\n * __useDeleteShareCertificateDisclaimerMutation__\n *\n * To run a mutation, you first call `useDeleteShareCertificateDisclaimerMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteShareCertificateDisclaimerMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteShareCertificateDisclaimerMutation, { data, loading, error }] = useDeleteShareCertificateDisclaimerMutation({\n *   variables: {\n *      disclaimer: // value for 'disclaimer'\n *   },\n * });\n */\nexport function useDeleteShareCertificateDisclaimerMutation(baseOptions?: Apollo.MutationHookOptions<DeleteShareCertificateDisclaimerMutation, DeleteShareCertificateDisclaimerMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteShareCertificateDisclaimerMutation, DeleteShareCertificateDisclaimerMutationVariables>(DeleteShareCertificateDisclaimerDocument, options);\n      }\nexport type DeleteShareCertificateDisclaimerMutationHookResult = ReturnType<typeof useDeleteShareCertificateDisclaimerMutation>;\nexport type DeleteShareCertificateDisclaimerMutationResult = Apollo.MutationResult<DeleteShareCertificateDisclaimerMutation>;\nexport type DeleteShareCertificateDisclaimerMutationOptions = Apollo.BaseMutationOptions<DeleteShareCertificateDisclaimerMutation, DeleteShareCertificateDisclaimerMutationVariables>;\nexport const ShareCertificateDisclaimerDocument: TypedDocumentNode<ShareCertificateDisclaimerQuery, ShareCertificateDisclaimerQueryVariables> = gql`\n  query shareCertificateDisclaimer($disclaimer: ShareCertificateDisclaimerCakeType!) {\n  shareCertificateDisclaimer(disclaimer: $disclaimer) {\n    id\n    sharetypeDefault {\n      id\n    }\n    name\n    disclaimerText\n  }\n}\n    `;\n\n/**\n * __useShareCertificateDisclaimerQuery__\n *\n * To run a query within a React component, call `useShareCertificateDisclaimerQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareCertificateDisclaimerQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareCertificateDisclaimerQuery({\n *   variables: {\n *      disclaimer: // value for 'disclaimer'\n *   },\n * });\n */\nexport function useShareCertificateDisclaimerQuery(baseOptions: Apollo.QueryHookOptions<ShareCertificateDisclaimerQuery, ShareCertificateDisclaimerQueryVariables> & ({ variables: ShareCertificateDisclaimerQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareCertificateDisclaimerQuery, ShareCertificateDisclaimerQueryVariables>(ShareCertificateDisclaimerDocument, options);\n      }\nexport function useShareCertificateDisclaimerLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareCertificateDisclaimerQuery, ShareCertificateDisclaimerQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareCertificateDisclaimerQuery, ShareCertificateDisclaimerQueryVariables>(ShareCertificateDisclaimerDocument, options);\n        }\nexport function useShareCertificateDisclaimerSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareCertificateDisclaimerQuery, ShareCertificateDisclaimerQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareCertificateDisclaimerQuery, ShareCertificateDisclaimerQueryVariables>(ShareCertificateDisclaimerDocument, options);\n        }\nexport type ShareCertificateDisclaimerQueryHookResult = ReturnType<typeof useShareCertificateDisclaimerQuery>;\nexport type ShareCertificateDisclaimerLazyQueryHookResult = ReturnType<typeof useShareCertificateDisclaimerLazyQuery>;\nexport type ShareCertificateDisclaimerSuspenseQueryHookResult = ReturnType<typeof useShareCertificateDisclaimerSuspenseQuery>;\nexport type ShareCertificateDisclaimerQueryResult = Apollo.QueryResult<ShareCertificateDisclaimerQuery, ShareCertificateDisclaimerQueryVariables>;\nexport function refetchShareCertificateDisclaimerQuery(variables: ShareCertificateDisclaimerQueryVariables) {\n      return { query: ShareCertificateDisclaimerDocument, variables: variables };\n    }\nexport const ShareCertificateDisclaimersListDocument: TypedDocumentNode<ShareCertificateDisclaimersListQuery, ShareCertificateDisclaimersListQueryVariables> = gql`\n  query shareCertificateDisclaimersList($organisation: OrganisationCakeType!, $organisationId: UUID!) {\n  shareCertificateDisclaimersList(organisation: $organisation) {\n    id\n    name\n    disclaimerText\n    sharetypeDefault {\n      id\n      name\n      symbol\n    }\n  }\n  sharetypes(organisationId: $organisationId) {\n    id\n    name\n    symbol\n  }\n}\n    `;\n\n/**\n * __useShareCertificateDisclaimersListQuery__\n *\n * To run a query within a React component, call `useShareCertificateDisclaimersListQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareCertificateDisclaimersListQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareCertificateDisclaimersListQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useShareCertificateDisclaimersListQuery(baseOptions: Apollo.QueryHookOptions<ShareCertificateDisclaimersListQuery, ShareCertificateDisclaimersListQueryVariables> & ({ variables: ShareCertificateDisclaimersListQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareCertificateDisclaimersListQuery, ShareCertificateDisclaimersListQueryVariables>(ShareCertificateDisclaimersListDocument, options);\n      }\nexport function useShareCertificateDisclaimersListLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareCertificateDisclaimersListQuery, ShareCertificateDisclaimersListQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareCertificateDisclaimersListQuery, ShareCertificateDisclaimersListQueryVariables>(ShareCertificateDisclaimersListDocument, options);\n        }\nexport function useShareCertificateDisclaimersListSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareCertificateDisclaimersListQuery, ShareCertificateDisclaimersListQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareCertificateDisclaimersListQuery, ShareCertificateDisclaimersListQueryVariables>(ShareCertificateDisclaimersListDocument, options);\n        }\nexport type ShareCertificateDisclaimersListQueryHookResult = ReturnType<typeof useShareCertificateDisclaimersListQuery>;\nexport type ShareCertificateDisclaimersListLazyQueryHookResult = ReturnType<typeof useShareCertificateDisclaimersListLazyQuery>;\nexport type ShareCertificateDisclaimersListSuspenseQueryHookResult = ReturnType<typeof useShareCertificateDisclaimersListSuspenseQuery>;\nexport type ShareCertificateDisclaimersListQueryResult = Apollo.QueryResult<ShareCertificateDisclaimersListQuery, ShareCertificateDisclaimersListQueryVariables>;\nexport function refetchShareCertificateDisclaimersListQuery(variables: ShareCertificateDisclaimersListQueryVariables) {\n      return { query: ShareCertificateDisclaimersListDocument, variables: variables };\n    }\nexport const GetCopilotOnboardingDataDocument: TypedDocumentNode<GetCopilotOnboardingDataQuery, GetCopilotOnboardingDataQueryVariables> = gql`\n  query getCopilotOnboardingData($organisationId: UUID!, $userId: UUID!) {\n  organisationUserRolePosition(organisationId: $organisationId, userId: $userId) {\n    role\n    position\n  }\n  organisation(organisationId: $organisationId) {\n    name\n    logo\n  }\n  userInviteSender\n}\n    `;\n\n/**\n * __useGetCopilotOnboardingDataQuery__\n *\n * To run a query within a React component, call `useGetCopilotOnboardingDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetCopilotOnboardingDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetCopilotOnboardingDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      userId: // value for 'userId'\n *   },\n * });\n */\nexport function useGetCopilotOnboardingDataQuery(baseOptions: Apollo.QueryHookOptions<GetCopilotOnboardingDataQuery, GetCopilotOnboardingDataQueryVariables> & ({ variables: GetCopilotOnboardingDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetCopilotOnboardingDataQuery, GetCopilotOnboardingDataQueryVariables>(GetCopilotOnboardingDataDocument, options);\n      }\nexport function useGetCopilotOnboardingDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCopilotOnboardingDataQuery, GetCopilotOnboardingDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetCopilotOnboardingDataQuery, GetCopilotOnboardingDataQueryVariables>(GetCopilotOnboardingDataDocument, options);\n        }\nexport function useGetCopilotOnboardingDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetCopilotOnboardingDataQuery, GetCopilotOnboardingDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetCopilotOnboardingDataQuery, GetCopilotOnboardingDataQueryVariables>(GetCopilotOnboardingDataDocument, options);\n        }\nexport type GetCopilotOnboardingDataQueryHookResult = ReturnType<typeof useGetCopilotOnboardingDataQuery>;\nexport type GetCopilotOnboardingDataLazyQueryHookResult = ReturnType<typeof useGetCopilotOnboardingDataLazyQuery>;\nexport type GetCopilotOnboardingDataSuspenseQueryHookResult = ReturnType<typeof useGetCopilotOnboardingDataSuspenseQuery>;\nexport type GetCopilotOnboardingDataQueryResult = Apollo.QueryResult<GetCopilotOnboardingDataQuery, GetCopilotOnboardingDataQueryVariables>;\nexport function refetchGetCopilotOnboardingDataQuery(variables: GetCopilotOnboardingDataQueryVariables) {\n      return { query: GetCopilotOnboardingDataDocument, variables: variables };\n    }\nexport const RevertCancelSubscriptionDocument: TypedDocumentNode<RevertCancelSubscriptionMutation, RevertCancelSubscriptionMutationVariables> = gql`\n  mutation revertCancelSubscription($organisation: OrganisationCakeType!) {\n  revertCancelSubscription(organisation: $organisation)\n}\n    `;\nexport type RevertCancelSubscriptionMutationFn = Apollo.MutationFunction<RevertCancelSubscriptionMutation, RevertCancelSubscriptionMutationVariables>;\n\n/**\n * __useRevertCancelSubscriptionMutation__\n *\n * To run a mutation, you first call `useRevertCancelSubscriptionMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRevertCancelSubscriptionMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [revertCancelSubscriptionMutation, { data, loading, error }] = useRevertCancelSubscriptionMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useRevertCancelSubscriptionMutation(baseOptions?: Apollo.MutationHookOptions<RevertCancelSubscriptionMutation, RevertCancelSubscriptionMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RevertCancelSubscriptionMutation, RevertCancelSubscriptionMutationVariables>(RevertCancelSubscriptionDocument, options);\n      }\nexport type RevertCancelSubscriptionMutationHookResult = ReturnType<typeof useRevertCancelSubscriptionMutation>;\nexport type RevertCancelSubscriptionMutationResult = Apollo.MutationResult<RevertCancelSubscriptionMutation>;\nexport type RevertCancelSubscriptionMutationOptions = Apollo.BaseMutationOptions<RevertCancelSubscriptionMutation, RevertCancelSubscriptionMutationVariables>;\nexport const PaginatedShareholdersDocument: TypedDocumentNode<PaginatedShareholdersQuery, PaginatedShareholdersQueryVariables> = gql`\n  query paginatedShareholders($organisationId: UUID!, $page: Int!, $itemsPerPage: Int!, $search: String, $shareholderIdsToExclude: [UUID]) {\n  paginatedShareholders(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    search: $search\n    excludeByIds: $shareholderIdsToExclude\n  ) {\n    notSignedUpCount\n    count\n    currentPage\n    pageData {\n      hasLoggedIn\n      consideredInvited\n      id\n      displayName\n      avatar\n      secondaryName\n      trustName\n      recipient {\n        id\n        displayName\n      }\n      trust {\n        id\n      }\n      investorData {\n        name\n        email\n        address {\n          country\n          administrativeArea1\n        }\n        companyData {\n          contactPerson\n        }\n      }\n      employeeData {\n        role\n        level\n      }\n      computedType\n    }\n  }\n}\n    `;\n\n/**\n * __usePaginatedShareholdersQuery__\n *\n * To run a query within a React component, call `usePaginatedShareholdersQuery` and pass it any options that fit your needs.\n * When your component renders, `usePaginatedShareholdersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = usePaginatedShareholdersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      search: // value for 'search'\n *      shareholderIdsToExclude: // value for 'shareholderIdsToExclude'\n *   },\n * });\n */\nexport function usePaginatedShareholdersQuery(baseOptions: Apollo.QueryHookOptions<PaginatedShareholdersQuery, PaginatedShareholdersQueryVariables> & ({ variables: PaginatedShareholdersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<PaginatedShareholdersQuery, PaginatedShareholdersQueryVariables>(PaginatedShareholdersDocument, options);\n      }\nexport function usePaginatedShareholdersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PaginatedShareholdersQuery, PaginatedShareholdersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<PaginatedShareholdersQuery, PaginatedShareholdersQueryVariables>(PaginatedShareholdersDocument, options);\n        }\nexport function usePaginatedShareholdersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PaginatedShareholdersQuery, PaginatedShareholdersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<PaginatedShareholdersQuery, PaginatedShareholdersQueryVariables>(PaginatedShareholdersDocument, options);\n        }\nexport type PaginatedShareholdersQueryHookResult = ReturnType<typeof usePaginatedShareholdersQuery>;\nexport type PaginatedShareholdersLazyQueryHookResult = ReturnType<typeof usePaginatedShareholdersLazyQuery>;\nexport type PaginatedShareholdersSuspenseQueryHookResult = ReturnType<typeof usePaginatedShareholdersSuspenseQuery>;\nexport type PaginatedShareholdersQueryResult = Apollo.QueryResult<PaginatedShareholdersQuery, PaginatedShareholdersQueryVariables>;\nexport function refetchPaginatedShareholdersQuery(variables: PaginatedShareholdersQueryVariables) {\n      return { query: PaginatedShareholdersDocument, variables: variables };\n    }\nexport const ShareholderNamesDocument: TypedDocumentNode<ShareholderNamesQuery, ShareholderNamesQueryVariables> = gql`\n  query shareholderNames($organisationId: OrganisationCakeType!) {\n  shareholderNames(organisation: $organisationId)\n}\n    `;\n\n/**\n * __useShareholderNamesQuery__\n *\n * To run a query within a React component, call `useShareholderNamesQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareholderNamesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareholderNamesQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useShareholderNamesQuery(baseOptions: Apollo.QueryHookOptions<ShareholderNamesQuery, ShareholderNamesQueryVariables> & ({ variables: ShareholderNamesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareholderNamesQuery, ShareholderNamesQueryVariables>(ShareholderNamesDocument, options);\n      }\nexport function useShareholderNamesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareholderNamesQuery, ShareholderNamesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareholderNamesQuery, ShareholderNamesQueryVariables>(ShareholderNamesDocument, options);\n        }\nexport function useShareholderNamesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareholderNamesQuery, ShareholderNamesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareholderNamesQuery, ShareholderNamesQueryVariables>(ShareholderNamesDocument, options);\n        }\nexport type ShareholderNamesQueryHookResult = ReturnType<typeof useShareholderNamesQuery>;\nexport type ShareholderNamesLazyQueryHookResult = ReturnType<typeof useShareholderNamesLazyQuery>;\nexport type ShareholderNamesSuspenseQueryHookResult = ReturnType<typeof useShareholderNamesSuspenseQuery>;\nexport type ShareholderNamesQueryResult = Apollo.QueryResult<ShareholderNamesQuery, ShareholderNamesQueryVariables>;\nexport function refetchShareholderNamesQuery(variables: ShareholderNamesQueryVariables) {\n      return { query: ShareholderNamesDocument, variables: variables };\n    }\nexport const ShareholdersCountDocument: TypedDocumentNode<ShareholdersCountQuery, ShareholdersCountQueryVariables> = gql`\n  query shareholdersCount($organisationId: OrganisationCakeType!) {\n  shareholdersCount(organisation: $organisationId)\n}\n    `;\n\n/**\n * __useShareholdersCountQuery__\n *\n * To run a query within a React component, call `useShareholdersCountQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareholdersCountQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareholdersCountQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useShareholdersCountQuery(baseOptions: Apollo.QueryHookOptions<ShareholdersCountQuery, ShareholdersCountQueryVariables> & ({ variables: ShareholdersCountQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareholdersCountQuery, ShareholdersCountQueryVariables>(ShareholdersCountDocument, options);\n      }\nexport function useShareholdersCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareholdersCountQuery, ShareholdersCountQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareholdersCountQuery, ShareholdersCountQueryVariables>(ShareholdersCountDocument, options);\n        }\nexport function useShareholdersCountSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareholdersCountQuery, ShareholdersCountQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareholdersCountQuery, ShareholdersCountQueryVariables>(ShareholdersCountDocument, options);\n        }\nexport type ShareholdersCountQueryHookResult = ReturnType<typeof useShareholdersCountQuery>;\nexport type ShareholdersCountLazyQueryHookResult = ReturnType<typeof useShareholdersCountLazyQuery>;\nexport type ShareholdersCountSuspenseQueryHookResult = ReturnType<typeof useShareholdersCountSuspenseQuery>;\nexport type ShareholdersCountQueryResult = Apollo.QueryResult<ShareholdersCountQuery, ShareholdersCountQueryVariables>;\nexport function refetchShareholdersCountQuery(variables: ShareholdersCountQueryVariables) {\n      return { query: ShareholdersCountDocument, variables: variables };\n    }\nexport const ShareholdersWithShareholdingsDocument: TypedDocumentNode<ShareholdersWithShareholdingsQuery, ShareholdersWithShareholdingsQueryVariables> = gql`\n  query shareholdersWithShareholdings($organisationId: UUID!, $page: Int!, $itemsPerPage: Int!, $search: String) {\n  paginatedShareholders(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    search: $search\n  ) {\n    count\n    currentPage\n    pageData {\n      id\n      displayName\n      avatar\n      trust {\n        id\n      }\n      groupedShareholdings {\n        totalShares\n        totalInvested\n        totalUnpaid\n        sharetype {\n          name\n          id\n          symbol\n        }\n      }\n      investorData {\n        name\n        email\n        companyData {\n          contactPerson\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useShareholdersWithShareholdingsQuery__\n *\n * To run a query within a React component, call `useShareholdersWithShareholdingsQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareholdersWithShareholdingsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareholdersWithShareholdingsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useShareholdersWithShareholdingsQuery(baseOptions: Apollo.QueryHookOptions<ShareholdersWithShareholdingsQuery, ShareholdersWithShareholdingsQueryVariables> & ({ variables: ShareholdersWithShareholdingsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareholdersWithShareholdingsQuery, ShareholdersWithShareholdingsQueryVariables>(ShareholdersWithShareholdingsDocument, options);\n      }\nexport function useShareholdersWithShareholdingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareholdersWithShareholdingsQuery, ShareholdersWithShareholdingsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareholdersWithShareholdingsQuery, ShareholdersWithShareholdingsQueryVariables>(ShareholdersWithShareholdingsDocument, options);\n        }\nexport function useShareholdersWithShareholdingsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareholdersWithShareholdingsQuery, ShareholdersWithShareholdingsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareholdersWithShareholdingsQuery, ShareholdersWithShareholdingsQueryVariables>(ShareholdersWithShareholdingsDocument, options);\n        }\nexport type ShareholdersWithShareholdingsQueryHookResult = ReturnType<typeof useShareholdersWithShareholdingsQuery>;\nexport type ShareholdersWithShareholdingsLazyQueryHookResult = ReturnType<typeof useShareholdersWithShareholdingsLazyQuery>;\nexport type ShareholdersWithShareholdingsSuspenseQueryHookResult = ReturnType<typeof useShareholdersWithShareholdingsSuspenseQuery>;\nexport type ShareholdersWithShareholdingsQueryResult = Apollo.QueryResult<ShareholdersWithShareholdingsQuery, ShareholdersWithShareholdingsQueryVariables>;\nexport function refetchShareholdersWithShareholdingsQuery(variables: ShareholdersWithShareholdingsQueryVariables) {\n      return { query: ShareholdersWithShareholdingsDocument, variables: variables };\n    }\nexport const GetShareholdersWithSharesAtDateDocument: TypedDocumentNode<GetShareholdersWithSharesAtDateQuery, GetShareholdersWithSharesAtDateQueryVariables> = gql`\n  query getShareholdersWithSharesAtDate($organisation: OrganisationCakeType!) {\n  shareholdersWithSharesAtDate(organisation: $organisation) {\n    id\n    displayName\n    avatar\n    investorData {\n      email\n    }\n  }\n}\n    `;\n\n/**\n * __useGetShareholdersWithSharesAtDateQuery__\n *\n * To run a query within a React component, call `useGetShareholdersWithSharesAtDateQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetShareholdersWithSharesAtDateQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetShareholdersWithSharesAtDateQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useGetShareholdersWithSharesAtDateQuery(baseOptions: Apollo.QueryHookOptions<GetShareholdersWithSharesAtDateQuery, GetShareholdersWithSharesAtDateQueryVariables> & ({ variables: GetShareholdersWithSharesAtDateQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetShareholdersWithSharesAtDateQuery, GetShareholdersWithSharesAtDateQueryVariables>(GetShareholdersWithSharesAtDateDocument, options);\n      }\nexport function useGetShareholdersWithSharesAtDateLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetShareholdersWithSharesAtDateQuery, GetShareholdersWithSharesAtDateQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetShareholdersWithSharesAtDateQuery, GetShareholdersWithSharesAtDateQueryVariables>(GetShareholdersWithSharesAtDateDocument, options);\n        }\nexport function useGetShareholdersWithSharesAtDateSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetShareholdersWithSharesAtDateQuery, GetShareholdersWithSharesAtDateQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetShareholdersWithSharesAtDateQuery, GetShareholdersWithSharesAtDateQueryVariables>(GetShareholdersWithSharesAtDateDocument, options);\n        }\nexport type GetShareholdersWithSharesAtDateQueryHookResult = ReturnType<typeof useGetShareholdersWithSharesAtDateQuery>;\nexport type GetShareholdersWithSharesAtDateLazyQueryHookResult = ReturnType<typeof useGetShareholdersWithSharesAtDateLazyQuery>;\nexport type GetShareholdersWithSharesAtDateSuspenseQueryHookResult = ReturnType<typeof useGetShareholdersWithSharesAtDateSuspenseQuery>;\nexport type GetShareholdersWithSharesAtDateQueryResult = Apollo.QueryResult<GetShareholdersWithSharesAtDateQuery, GetShareholdersWithSharesAtDateQueryVariables>;\nexport function refetchGetShareholdersWithSharesAtDateQuery(variables: GetShareholdersWithSharesAtDateQueryVariables) {\n      return { query: GetShareholdersWithSharesAtDateDocument, variables: variables };\n    }\nexport const GetShareholdersPageDataDocument: TypedDocumentNode<GetShareholdersPageDataQuery, GetShareholdersPageDataQueryVariables> = gql`\n  query getShareholdersPageData($organisationId: UUID!, $organisation: OrganisationCakeType!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $search: CleanString) {\n  shareholdersList(\n    organisation: $organisation\n    page: $page\n    itemsPerPage: $itemsPerPage\n    search: $search\n  ) {\n    pageData {\n      id\n      displayName\n      avatar\n      email\n      secondaryName\n      stakeholderType\n      consideredInvited\n      hasLoggedIn\n      isGeneratingCertificate\n      lastCertificateId\n      lastCertificateName\n      sharetypeHoldings {\n        id\n        symbol\n        name\n        shares\n        realShares\n        investment\n        totalUnpaid\n        unvestedShares\n      }\n      isTrust\n      totalShares\n    }\n    notSignedUpCount\n    currentPage\n    count\n  }\n  organisation(organisationId: $organisationId) {\n    lastCertificateNumber\n    totalShares\n    totalSharesUnexercised\n    fundingPhase\n    shareCertificateType\n  }\n  sharetypes(organisationId: $organisationId) {\n    id\n    name\n    symbol\n    totals {\n      totalShares\n      amountRaised\n      totalDue\n    }\n    authorisedShares\n  }\n  esss(organisationId: $organisationId, itemsPerPage: 1) {\n    id\n  }\n  founderVestings(organisationId: $organisationId, itemsPerPage: 1) {\n    id\n  }\n  canEditOnboardedShareholders(organisation: $organisation)\n}\n    `;\n\n/**\n * __useGetShareholdersPageDataQuery__\n *\n * To run a query within a React component, call `useGetShareholdersPageDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetShareholdersPageDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetShareholdersPageDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      organisation: // value for 'organisation'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetShareholdersPageDataQuery(baseOptions: Apollo.QueryHookOptions<GetShareholdersPageDataQuery, GetShareholdersPageDataQueryVariables> & ({ variables: GetShareholdersPageDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetShareholdersPageDataQuery, GetShareholdersPageDataQueryVariables>(GetShareholdersPageDataDocument, options);\n      }\nexport function useGetShareholdersPageDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetShareholdersPageDataQuery, GetShareholdersPageDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetShareholdersPageDataQuery, GetShareholdersPageDataQueryVariables>(GetShareholdersPageDataDocument, options);\n        }\nexport function useGetShareholdersPageDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetShareholdersPageDataQuery, GetShareholdersPageDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetShareholdersPageDataQuery, GetShareholdersPageDataQueryVariables>(GetShareholdersPageDataDocument, options);\n        }\nexport type GetShareholdersPageDataQueryHookResult = ReturnType<typeof useGetShareholdersPageDataQuery>;\nexport type GetShareholdersPageDataLazyQueryHookResult = ReturnType<typeof useGetShareholdersPageDataLazyQuery>;\nexport type GetShareholdersPageDataSuspenseQueryHookResult = ReturnType<typeof useGetShareholdersPageDataSuspenseQuery>;\nexport type GetShareholdersPageDataQueryResult = Apollo.QueryResult<GetShareholdersPageDataQuery, GetShareholdersPageDataQueryVariables>;\nexport function refetchGetShareholdersPageDataQuery(variables: GetShareholdersPageDataQueryVariables) {\n      return { query: GetShareholdersPageDataDocument, variables: variables };\n    }\nexport const ShareholderTransactionsDocument: TypedDocumentNode<ShareholderTransactionsQuery, ShareholderTransactionsQueryVariables> = gql`\n  query shareholderTransactions($shareholderId: UUID!) {\n  shareholderTransactions(shareholderId: $shareholderId) {\n    shareholdings {\n      transactionId\n      shareholderId\n      transactionDate\n      transactionType\n      shares\n      amount\n      unpaid\n      shareSplitFactor\n      paidInTransfer\n      accumulatedShares\n      sharetype {\n        symbol\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useShareholderTransactionsQuery__\n *\n * To run a query within a React component, call `useShareholderTransactionsQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareholderTransactionsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareholderTransactionsQuery({\n *   variables: {\n *      shareholderId: // value for 'shareholderId'\n *   },\n * });\n */\nexport function useShareholderTransactionsQuery(baseOptions: Apollo.QueryHookOptions<ShareholderTransactionsQuery, ShareholderTransactionsQueryVariables> & ({ variables: ShareholderTransactionsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareholderTransactionsQuery, ShareholderTransactionsQueryVariables>(ShareholderTransactionsDocument, options);\n      }\nexport function useShareholderTransactionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareholderTransactionsQuery, ShareholderTransactionsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareholderTransactionsQuery, ShareholderTransactionsQueryVariables>(ShareholderTransactionsDocument, options);\n        }\nexport function useShareholderTransactionsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareholderTransactionsQuery, ShareholderTransactionsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareholderTransactionsQuery, ShareholderTransactionsQueryVariables>(ShareholderTransactionsDocument, options);\n        }\nexport type ShareholderTransactionsQueryHookResult = ReturnType<typeof useShareholderTransactionsQuery>;\nexport type ShareholderTransactionsLazyQueryHookResult = ReturnType<typeof useShareholderTransactionsLazyQuery>;\nexport type ShareholderTransactionsSuspenseQueryHookResult = ReturnType<typeof useShareholderTransactionsSuspenseQuery>;\nexport type ShareholderTransactionsQueryResult = Apollo.QueryResult<ShareholderTransactionsQuery, ShareholderTransactionsQueryVariables>;\nexport function refetchShareholderTransactionsQuery(variables: ShareholderTransactionsQueryVariables) {\n      return { query: ShareholderTransactionsDocument, variables: variables };\n    }\nexport const GetShareholdersToEditTransactionsDocument: TypedDocumentNode<GetShareholdersToEditTransactionsQuery, GetShareholdersToEditTransactionsQueryVariables> = gql`\n  query getShareholdersToEditTransactions($organisationId: UUID!) {\n  shareholdersWithShareholdings(organisationId: $organisationId) {\n    pageData {\n      id\n      displayName\n      avatar\n      primaryEmail\n      shareholdings {\n        shares\n        amount\n        transactionDate\n        sharetype {\n          id\n          name\n          symbol\n        }\n      }\n    }\n  }\n  sharetypes(organisationId: $organisationId) {\n    id\n    name\n    symbol\n  }\n}\n    `;\n\n/**\n * __useGetShareholdersToEditTransactionsQuery__\n *\n * To run a query within a React component, call `useGetShareholdersToEditTransactionsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetShareholdersToEditTransactionsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetShareholdersToEditTransactionsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetShareholdersToEditTransactionsQuery(baseOptions: Apollo.QueryHookOptions<GetShareholdersToEditTransactionsQuery, GetShareholdersToEditTransactionsQueryVariables> & ({ variables: GetShareholdersToEditTransactionsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetShareholdersToEditTransactionsQuery, GetShareholdersToEditTransactionsQueryVariables>(GetShareholdersToEditTransactionsDocument, options);\n      }\nexport function useGetShareholdersToEditTransactionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetShareholdersToEditTransactionsQuery, GetShareholdersToEditTransactionsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetShareholdersToEditTransactionsQuery, GetShareholdersToEditTransactionsQueryVariables>(GetShareholdersToEditTransactionsDocument, options);\n        }\nexport function useGetShareholdersToEditTransactionsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetShareholdersToEditTransactionsQuery, GetShareholdersToEditTransactionsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetShareholdersToEditTransactionsQuery, GetShareholdersToEditTransactionsQueryVariables>(GetShareholdersToEditTransactionsDocument, options);\n        }\nexport type GetShareholdersToEditTransactionsQueryHookResult = ReturnType<typeof useGetShareholdersToEditTransactionsQuery>;\nexport type GetShareholdersToEditTransactionsLazyQueryHookResult = ReturnType<typeof useGetShareholdersToEditTransactionsLazyQuery>;\nexport type GetShareholdersToEditTransactionsSuspenseQueryHookResult = ReturnType<typeof useGetShareholdersToEditTransactionsSuspenseQuery>;\nexport type GetShareholdersToEditTransactionsQueryResult = Apollo.QueryResult<GetShareholdersToEditTransactionsQuery, GetShareholdersToEditTransactionsQueryVariables>;\nexport function refetchGetShareholdersToEditTransactionsQuery(variables: GetShareholdersToEditTransactionsQueryVariables) {\n      return { query: GetShareholdersToEditTransactionsDocument, variables: variables };\n    }\nexport const GetSignerOfficeholdersDocument: TypedDocumentNode<GetSignerOfficeholdersQuery, GetSignerOfficeholdersQueryVariables> = gql`\n  query getSignerOfficeholders($organisationId: UUID!) {\n  officeholders(organisationId: $organisationId, filterSigners: true) {\n    id\n    name\n    email\n    avatar\n    roles {\n      role\n      name\n    }\n    signer\n    signature\n  }\n}\n    `;\n\n/**\n * __useGetSignerOfficeholdersQuery__\n *\n * To run a query within a React component, call `useGetSignerOfficeholdersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetSignerOfficeholdersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetSignerOfficeholdersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetSignerOfficeholdersQuery(baseOptions: Apollo.QueryHookOptions<GetSignerOfficeholdersQuery, GetSignerOfficeholdersQueryVariables> & ({ variables: GetSignerOfficeholdersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetSignerOfficeholdersQuery, GetSignerOfficeholdersQueryVariables>(GetSignerOfficeholdersDocument, options);\n      }\nexport function useGetSignerOfficeholdersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetSignerOfficeholdersQuery, GetSignerOfficeholdersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetSignerOfficeholdersQuery, GetSignerOfficeholdersQueryVariables>(GetSignerOfficeholdersDocument, options);\n        }\nexport function useGetSignerOfficeholdersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetSignerOfficeholdersQuery, GetSignerOfficeholdersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetSignerOfficeholdersQuery, GetSignerOfficeholdersQueryVariables>(GetSignerOfficeholdersDocument, options);\n        }\nexport type GetSignerOfficeholdersQueryHookResult = ReturnType<typeof useGetSignerOfficeholdersQuery>;\nexport type GetSignerOfficeholdersLazyQueryHookResult = ReturnType<typeof useGetSignerOfficeholdersLazyQuery>;\nexport type GetSignerOfficeholdersSuspenseQueryHookResult = ReturnType<typeof useGetSignerOfficeholdersSuspenseQuery>;\nexport type GetSignerOfficeholdersQueryResult = Apollo.QueryResult<GetSignerOfficeholdersQuery, GetSignerOfficeholdersQueryVariables>;\nexport function refetchGetSignerOfficeholdersQuery(variables: GetSignerOfficeholdersQueryVariables) {\n      return { query: GetSignerOfficeholdersDocument, variables: variables };\n    }\nexport const GetCertificateDetailsDocument: TypedDocumentNode<GetCertificateDetailsQuery, GetCertificateDetailsQueryVariables> = gql`\n  query getCertificateDetails($organisationId: UUID!, $organisation: OrganisationCakeType!) {\n  organisation(organisationId: $organisationId) {\n    name\n    country\n    logoImage\n    lastCertificateNumber\n    totalShares\n    companyDetails {\n      ... on AuCompanyDetailsField {\n        acn\n        registrationLocation\n        registeredAgentName\n        registeredAgentEmail\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on SgCompanyDetailsField {\n        uen\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on UsCompanyDetailsField {\n        stateOfRegistration\n        ein\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on GbCompanyDetailsField {\n        crn\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on NzCompanyDetailsField {\n        nzbn\n        registeredAgentName\n        registeredAgentEmail\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on InCompanyDetailsField {\n        cin\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on CaCompanyDetailsField {\n        bn\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n      ... on EeCompanyDetailsField {\n        brc\n        registeredAddress {\n          line1\n          line2\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n      }\n    }\n  }\n  officeholders(organisationId: $organisationId, filterSigners: true) {\n    id\n    name\n    email\n    avatar\n    roles {\n      role\n      name\n    }\n    signer\n    signature\n  }\n  shareCertificateDisclaimersList(organisation: $organisation) {\n    id\n    name\n    sharetypeDefault {\n      id\n      name\n      symbol\n    }\n  }\n}\n    `;\n\n/**\n * __useGetCertificateDetailsQuery__\n *\n * To run a query within a React component, call `useGetCertificateDetailsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetCertificateDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetCertificateDetailsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useGetCertificateDetailsQuery(baseOptions: Apollo.QueryHookOptions<GetCertificateDetailsQuery, GetCertificateDetailsQueryVariables> & ({ variables: GetCertificateDetailsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetCertificateDetailsQuery, GetCertificateDetailsQueryVariables>(GetCertificateDetailsDocument, options);\n      }\nexport function useGetCertificateDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCertificateDetailsQuery, GetCertificateDetailsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetCertificateDetailsQuery, GetCertificateDetailsQueryVariables>(GetCertificateDetailsDocument, options);\n        }\nexport function useGetCertificateDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetCertificateDetailsQuery, GetCertificateDetailsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetCertificateDetailsQuery, GetCertificateDetailsQueryVariables>(GetCertificateDetailsDocument, options);\n        }\nexport type GetCertificateDetailsQueryHookResult = ReturnType<typeof useGetCertificateDetailsQuery>;\nexport type GetCertificateDetailsLazyQueryHookResult = ReturnType<typeof useGetCertificateDetailsLazyQuery>;\nexport type GetCertificateDetailsSuspenseQueryHookResult = ReturnType<typeof useGetCertificateDetailsSuspenseQuery>;\nexport type GetCertificateDetailsQueryResult = Apollo.QueryResult<GetCertificateDetailsQuery, GetCertificateDetailsQueryVariables>;\nexport function refetchGetCertificateDetailsQuery(variables: GetCertificateDetailsQueryVariables) {\n      return { query: GetCertificateDetailsDocument, variables: variables };\n    }\nexport const AddShareholderDocument: TypedDocumentNode<AddShareholderMutation, AddShareholderMutationVariables> = gql`\n  mutation addShareholder($organisation: OrganisationCakeType!, $shareholderDataList: [ShareholderDataInput]!) {\n  addShareholder(\n    organisation: $organisation\n    shareholderDataInputList: $shareholderDataList\n  ) {\n    id\n    investorData {\n      email\n    }\n  }\n}\n    `;\nexport type AddShareholderMutationFn = Apollo.MutationFunction<AddShareholderMutation, AddShareholderMutationVariables>;\n\n/**\n * __useAddShareholderMutation__\n *\n * To run a mutation, you first call `useAddShareholderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddShareholderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addShareholderMutation, { data, loading, error }] = useAddShareholderMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      shareholderDataList: // value for 'shareholderDataList'\n *   },\n * });\n */\nexport function useAddShareholderMutation(baseOptions?: Apollo.MutationHookOptions<AddShareholderMutation, AddShareholderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddShareholderMutation, AddShareholderMutationVariables>(AddShareholderDocument, options);\n      }\nexport type AddShareholderMutationHookResult = ReturnType<typeof useAddShareholderMutation>;\nexport type AddShareholderMutationResult = Apollo.MutationResult<AddShareholderMutation>;\nexport type AddShareholderMutationOptions = Apollo.BaseMutationOptions<AddShareholderMutation, AddShareholderMutationVariables>;\nexport const IssueSharesDocument: TypedDocumentNode<IssueSharesMutation, IssueSharesMutationVariables> = gql`\n  mutation issueShares($issueSharesInputList: [IssueSharesInput]!) {\n  issueShares(issueSharesInputList: $issueSharesInputList)\n}\n    `;\nexport type IssueSharesMutationFn = Apollo.MutationFunction<IssueSharesMutation, IssueSharesMutationVariables>;\n\n/**\n * __useIssueSharesMutation__\n *\n * To run a mutation, you first call `useIssueSharesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useIssueSharesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [issueSharesMutation, { data, loading, error }] = useIssueSharesMutation({\n *   variables: {\n *      issueSharesInputList: // value for 'issueSharesInputList'\n *   },\n * });\n */\nexport function useIssueSharesMutation(baseOptions?: Apollo.MutationHookOptions<IssueSharesMutation, IssueSharesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<IssueSharesMutation, IssueSharesMutationVariables>(IssueSharesDocument, options);\n      }\nexport type IssueSharesMutationHookResult = ReturnType<typeof useIssueSharesMutation>;\nexport type IssueSharesMutationResult = Apollo.MutationResult<IssueSharesMutation>;\nexport type IssueSharesMutationOptions = Apollo.BaseMutationOptions<IssueSharesMutation, IssueSharesMutationVariables>;\nexport const SetupSharetypesAndShareholdersDocument: TypedDocumentNode<SetupSharetypesAndShareholdersMutation, SetupSharetypesAndShareholdersMutationVariables> = gql`\n  mutation setupSharetypesAndShareholders($organisation: OrganisationCakeType!, $sharetypes: [CreateOrUpdateSharetypeInput!]!, $shareholderIssueSharesInputList: [ShareholderIssueSharesInput]!) {\n  setupSharetypes(sharetypes: $sharetypes, organisation: $organisation) {\n    id\n  }\n  addShareholderIssueShares(\n    organisation: $organisation\n    shareholderIssueSharesInputList: $shareholderIssueSharesInputList\n  ) {\n    id\n  }\n}\n    `;\nexport type SetupSharetypesAndShareholdersMutationFn = Apollo.MutationFunction<SetupSharetypesAndShareholdersMutation, SetupSharetypesAndShareholdersMutationVariables>;\n\n/**\n * __useSetupSharetypesAndShareholdersMutation__\n *\n * To run a mutation, you first call `useSetupSharetypesAndShareholdersMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSetupSharetypesAndShareholdersMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [setupSharetypesAndShareholdersMutation, { data, loading, error }] = useSetupSharetypesAndShareholdersMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      sharetypes: // value for 'sharetypes'\n *      shareholderIssueSharesInputList: // value for 'shareholderIssueSharesInputList'\n *   },\n * });\n */\nexport function useSetupSharetypesAndShareholdersMutation(baseOptions?: Apollo.MutationHookOptions<SetupSharetypesAndShareholdersMutation, SetupSharetypesAndShareholdersMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SetupSharetypesAndShareholdersMutation, SetupSharetypesAndShareholdersMutationVariables>(SetupSharetypesAndShareholdersDocument, options);\n      }\nexport type SetupSharetypesAndShareholdersMutationHookResult = ReturnType<typeof useSetupSharetypesAndShareholdersMutation>;\nexport type SetupSharetypesAndShareholdersMutationResult = Apollo.MutationResult<SetupSharetypesAndShareholdersMutation>;\nexport type SetupSharetypesAndShareholdersMutationOptions = Apollo.BaseMutationOptions<SetupSharetypesAndShareholdersMutation, SetupSharetypesAndShareholdersMutationVariables>;\nexport const IssueOfferSharesDocument: TypedDocumentNode<IssueOfferSharesMutation, IssueOfferSharesMutationVariables> = gql`\n  mutation issueOfferShares($offer: OrganisationRaiseOfferCakeType!, $certificateCount: Int!, $issueDate: Date) {\n  issueOfferShares(\n    offer: $offer\n    certificateCount: $certificateCount\n    issueDate: $issueDate\n  ) {\n    certificate {\n      id\n    }\n  }\n}\n    `;\nexport type IssueOfferSharesMutationFn = Apollo.MutationFunction<IssueOfferSharesMutation, IssueOfferSharesMutationVariables>;\n\n/**\n * __useIssueOfferSharesMutation__\n *\n * To run a mutation, you first call `useIssueOfferSharesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useIssueOfferSharesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [issueOfferSharesMutation, { data, loading, error }] = useIssueOfferSharesMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      certificateCount: // value for 'certificateCount'\n *      issueDate: // value for 'issueDate'\n *   },\n * });\n */\nexport function useIssueOfferSharesMutation(baseOptions?: Apollo.MutationHookOptions<IssueOfferSharesMutation, IssueOfferSharesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<IssueOfferSharesMutation, IssueOfferSharesMutationVariables>(IssueOfferSharesDocument, options);\n      }\nexport type IssueOfferSharesMutationHookResult = ReturnType<typeof useIssueOfferSharesMutation>;\nexport type IssueOfferSharesMutationResult = Apollo.MutationResult<IssueOfferSharesMutation>;\nexport type IssueOfferSharesMutationOptions = Apollo.BaseMutationOptions<IssueOfferSharesMutation, IssueOfferSharesMutationVariables>;\nexport const AddShareSplitDocument: TypedDocumentNode<AddShareSplitMutation, AddShareSplitMutationVariables> = gql`\n  mutation addShareSplit($shareType: SharetypeCakeType!, $splitFactor: CakeDecimal!, $splitDate: Date!) {\n  addShareSplit(\n    shareType: $shareType\n    splitFactor: $splitFactor\n    splitDate: $splitDate\n  ) {\n    id\n  }\n}\n    `;\nexport type AddShareSplitMutationFn = Apollo.MutationFunction<AddShareSplitMutation, AddShareSplitMutationVariables>;\n\n/**\n * __useAddShareSplitMutation__\n *\n * To run a mutation, you first call `useAddShareSplitMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddShareSplitMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addShareSplitMutation, { data, loading, error }] = useAddShareSplitMutation({\n *   variables: {\n *      shareType: // value for 'shareType'\n *      splitFactor: // value for 'splitFactor'\n *      splitDate: // value for 'splitDate'\n *   },\n * });\n */\nexport function useAddShareSplitMutation(baseOptions?: Apollo.MutationHookOptions<AddShareSplitMutation, AddShareSplitMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddShareSplitMutation, AddShareSplitMutationVariables>(AddShareSplitDocument, options);\n      }\nexport type AddShareSplitMutationHookResult = ReturnType<typeof useAddShareSplitMutation>;\nexport type AddShareSplitMutationResult = Apollo.MutationResult<AddShareSplitMutation>;\nexport type AddShareSplitMutationOptions = Apollo.BaseMutationOptions<AddShareSplitMutation, AddShareSplitMutationVariables>;\nexport const AddBuyBackDocument: TypedDocumentNode<AddBuyBackMutation, AddBuyBackMutationVariables> = gql`\n  mutation addBuyBack($addBuyBackData: AddBuyBackInput!) {\n  addBuyBack(addBuyBackData: $addBuyBackData) {\n    shareholdingTransaction {\n      id\n    }\n  }\n}\n    `;\nexport type AddBuyBackMutationFn = Apollo.MutationFunction<AddBuyBackMutation, AddBuyBackMutationVariables>;\n\n/**\n * __useAddBuyBackMutation__\n *\n * To run a mutation, you first call `useAddBuyBackMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddBuyBackMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addBuyBackMutation, { data, loading, error }] = useAddBuyBackMutation({\n *   variables: {\n *      addBuyBackData: // value for 'addBuyBackData'\n *   },\n * });\n */\nexport function useAddBuyBackMutation(baseOptions?: Apollo.MutationHookOptions<AddBuyBackMutation, AddBuyBackMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddBuyBackMutation, AddBuyBackMutationVariables>(AddBuyBackDocument, options);\n      }\nexport type AddBuyBackMutationHookResult = ReturnType<typeof useAddBuyBackMutation>;\nexport type AddBuyBackMutationResult = Apollo.MutationResult<AddBuyBackMutation>;\nexport type AddBuyBackMutationOptions = Apollo.BaseMutationOptions<AddBuyBackMutation, AddBuyBackMutationVariables>;\nexport const UpdateShareholderDocument: TypedDocumentNode<UpdateShareholderMutation, UpdateShareholderMutationVariables> = gql`\n  mutation updateShareholder($shareholderId: ShareholderCakeType!, $shareholderData: ShareholderDataInput!) {\n  updateShareholder(\n    shareholder: $shareholderId\n    shareholderDataInput: $shareholderData\n  ) {\n    id\n    displayName\n    avatar\n    trustAbn\n    heldInTrust\n    trustName\n    investorData {\n      name\n      email\n      phone\n      jointIndex\n      address {\n        line2\n        line1\n        locality\n        administrativeArea1\n        postcode\n        country\n      }\n      companyData {\n        contactPerson\n        identifierType\n        identifierNumber\n        signers {\n          name\n          email\n          role\n        }\n      }\n    }\n    comments\n  }\n}\n    `;\nexport type UpdateShareholderMutationFn = Apollo.MutationFunction<UpdateShareholderMutation, UpdateShareholderMutationVariables>;\n\n/**\n * __useUpdateShareholderMutation__\n *\n * To run a mutation, you first call `useUpdateShareholderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateShareholderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateShareholderMutation, { data, loading, error }] = useUpdateShareholderMutation({\n *   variables: {\n *      shareholderId: // value for 'shareholderId'\n *      shareholderData: // value for 'shareholderData'\n *   },\n * });\n */\nexport function useUpdateShareholderMutation(baseOptions?: Apollo.MutationHookOptions<UpdateShareholderMutation, UpdateShareholderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateShareholderMutation, UpdateShareholderMutationVariables>(UpdateShareholderDocument, options);\n      }\nexport type UpdateShareholderMutationHookResult = ReturnType<typeof useUpdateShareholderMutation>;\nexport type UpdateShareholderMutationResult = Apollo.MutationResult<UpdateShareholderMutation>;\nexport type UpdateShareholderMutationOptions = Apollo.BaseMutationOptions<UpdateShareholderMutation, UpdateShareholderMutationVariables>;\nexport const DeleteShareholdersDocument: TypedDocumentNode<DeleteShareholdersMutation, DeleteShareholdersMutationVariables> = gql`\n  mutation deleteShareholders($organisation: OrganisationCakeType!, $shareholderIdList: [ShareholderCakeType], $search: String) {\n  deleteShareholders(\n    organisation: $organisation\n    shareholders: $shareholderIdList\n    searchString: $search\n  ) {\n    deletionCount\n    existingTransactions {\n      name\n      reason\n    }\n  }\n}\n    `;\nexport type DeleteShareholdersMutationFn = Apollo.MutationFunction<DeleteShareholdersMutation, DeleteShareholdersMutationVariables>;\n\n/**\n * __useDeleteShareholdersMutation__\n *\n * To run a mutation, you first call `useDeleteShareholdersMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteShareholdersMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteShareholdersMutation, { data, loading, error }] = useDeleteShareholdersMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      shareholderIdList: // value for 'shareholderIdList'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useDeleteShareholdersMutation(baseOptions?: Apollo.MutationHookOptions<DeleteShareholdersMutation, DeleteShareholdersMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteShareholdersMutation, DeleteShareholdersMutationVariables>(DeleteShareholdersDocument, options);\n      }\nexport type DeleteShareholdersMutationHookResult = ReturnType<typeof useDeleteShareholdersMutation>;\nexport type DeleteShareholdersMutationResult = Apollo.MutationResult<DeleteShareholdersMutation>;\nexport type DeleteShareholdersMutationOptions = Apollo.BaseMutationOptions<DeleteShareholdersMutation, DeleteShareholdersMutationVariables>;\nexport const TransferSharesDocument: TypedDocumentNode<TransferSharesMutation, TransferSharesMutationVariables> = gql`\n  mutation transferShares($transferSharesData: TransferSharesData!) {\n  transferShares(transferSharesData: $transferSharesData) {\n    organisation {\n      id\n    }\n  }\n}\n    `;\nexport type TransferSharesMutationFn = Apollo.MutationFunction<TransferSharesMutation, TransferSharesMutationVariables>;\n\n/**\n * __useTransferSharesMutation__\n *\n * To run a mutation, you first call `useTransferSharesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useTransferSharesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [transferSharesMutation, { data, loading, error }] = useTransferSharesMutation({\n *   variables: {\n *      transferSharesData: // value for 'transferSharesData'\n *   },\n * });\n */\nexport function useTransferSharesMutation(baseOptions?: Apollo.MutationHookOptions<TransferSharesMutation, TransferSharesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<TransferSharesMutation, TransferSharesMutationVariables>(TransferSharesDocument, options);\n      }\nexport type TransferSharesMutationHookResult = ReturnType<typeof useTransferSharesMutation>;\nexport type TransferSharesMutationResult = Apollo.MutationResult<TransferSharesMutation>;\nexport type TransferSharesMutationOptions = Apollo.BaseMutationOptions<TransferSharesMutation, TransferSharesMutationVariables>;\nexport const GetShareSplitDetailsDocument: TypedDocumentNode<GetShareSplitDetailsQuery, GetShareSplitDetailsQueryVariables> = gql`\n  query getShareSplitDetails($transactionId: UUID!) {\n  getShareSplitDetails(transactionId: $transactionId) {\n    shareholderId\n    remainder\n    shares\n    shareholderName\n  }\n}\n    `;\n\n/**\n * __useGetShareSplitDetailsQuery__\n *\n * To run a query within a React component, call `useGetShareSplitDetailsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetShareSplitDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetShareSplitDetailsQuery({\n *   variables: {\n *      transactionId: // value for 'transactionId'\n *   },\n * });\n */\nexport function useGetShareSplitDetailsQuery(baseOptions: Apollo.QueryHookOptions<GetShareSplitDetailsQuery, GetShareSplitDetailsQueryVariables> & ({ variables: GetShareSplitDetailsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetShareSplitDetailsQuery, GetShareSplitDetailsQueryVariables>(GetShareSplitDetailsDocument, options);\n      }\nexport function useGetShareSplitDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetShareSplitDetailsQuery, GetShareSplitDetailsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetShareSplitDetailsQuery, GetShareSplitDetailsQueryVariables>(GetShareSplitDetailsDocument, options);\n        }\nexport function useGetShareSplitDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetShareSplitDetailsQuery, GetShareSplitDetailsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetShareSplitDetailsQuery, GetShareSplitDetailsQueryVariables>(GetShareSplitDetailsDocument, options);\n        }\nexport type GetShareSplitDetailsQueryHookResult = ReturnType<typeof useGetShareSplitDetailsQuery>;\nexport type GetShareSplitDetailsLazyQueryHookResult = ReturnType<typeof useGetShareSplitDetailsLazyQuery>;\nexport type GetShareSplitDetailsSuspenseQueryHookResult = ReturnType<typeof useGetShareSplitDetailsSuspenseQuery>;\nexport type GetShareSplitDetailsQueryResult = Apollo.QueryResult<GetShareSplitDetailsQuery, GetShareSplitDetailsQueryVariables>;\nexport function refetchGetShareSplitDetailsQuery(variables: GetShareSplitDetailsQueryVariables) {\n      return { query: GetShareSplitDetailsDocument, variables: variables };\n    }\nexport const ConvertSharesDocument: TypedDocumentNode<ConvertSharesMutation, ConvertSharesMutationVariables> = gql`\n  mutation convertShares($shareholderId: UUID!, $beneficiaryId: UUID, $fromSharetypeId: UUID!, $toSharetypeId: UUID!, $numberOfShares: PositiveInteger!, $splitFactor: CakeDecimal!, $conversionDate: Date!) {\n  convertShares(\n    shareholderId: $shareholderId\n    beneficiaryId: $beneficiaryId\n    fromSharetypeId: $fromSharetypeId\n    toSharetypeId: $toSharetypeId\n    numberOfShares: $numberOfShares\n    splitFactor: $splitFactor\n    conversionDate: $conversionDate\n  ) {\n    transactionFrom {\n      id\n    }\n  }\n}\n    `;\nexport type ConvertSharesMutationFn = Apollo.MutationFunction<ConvertSharesMutation, ConvertSharesMutationVariables>;\n\n/**\n * __useConvertSharesMutation__\n *\n * To run a mutation, you first call `useConvertSharesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useConvertSharesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [convertSharesMutation, { data, loading, error }] = useConvertSharesMutation({\n *   variables: {\n *      shareholderId: // value for 'shareholderId'\n *      beneficiaryId: // value for 'beneficiaryId'\n *      fromSharetypeId: // value for 'fromSharetypeId'\n *      toSharetypeId: // value for 'toSharetypeId'\n *      numberOfShares: // value for 'numberOfShares'\n *      splitFactor: // value for 'splitFactor'\n *      conversionDate: // value for 'conversionDate'\n *   },\n * });\n */\nexport function useConvertSharesMutation(baseOptions?: Apollo.MutationHookOptions<ConvertSharesMutation, ConvertSharesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ConvertSharesMutation, ConvertSharesMutationVariables>(ConvertSharesDocument, options);\n      }\nexport type ConvertSharesMutationHookResult = ReturnType<typeof useConvertSharesMutation>;\nexport type ConvertSharesMutationResult = Apollo.MutationResult<ConvertSharesMutation>;\nexport type ConvertSharesMutationOptions = Apollo.BaseMutationOptions<ConvertSharesMutation, ConvertSharesMutationVariables>;\nexport const UpdateSignerDocument: TypedDocumentNode<UpdateSignerMutation, UpdateSignerMutationVariables> = gql`\n  mutation updateSigner($officeholderId: UUID!, $isPrimary: Boolean!, $isDeleteOnly: Boolean!) {\n  updateSigner(\n    officeholderId: $officeholderId\n    isPrimary: $isPrimary\n    isDeleteOnly: $isDeleteOnly\n  ) {\n    ok\n  }\n}\n    `;\nexport type UpdateSignerMutationFn = Apollo.MutationFunction<UpdateSignerMutation, UpdateSignerMutationVariables>;\n\n/**\n * __useUpdateSignerMutation__\n *\n * To run a mutation, you first call `useUpdateSignerMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateSignerMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateSignerMutation, { data, loading, error }] = useUpdateSignerMutation({\n *   variables: {\n *      officeholderId: // value for 'officeholderId'\n *      isPrimary: // value for 'isPrimary'\n *      isDeleteOnly: // value for 'isDeleteOnly'\n *   },\n * });\n */\nexport function useUpdateSignerMutation(baseOptions?: Apollo.MutationHookOptions<UpdateSignerMutation, UpdateSignerMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateSignerMutation, UpdateSignerMutationVariables>(UpdateSignerDocument, options);\n      }\nexport type UpdateSignerMutationHookResult = ReturnType<typeof useUpdateSignerMutation>;\nexport type UpdateSignerMutationResult = Apollo.MutationResult<UpdateSignerMutation>;\nexport type UpdateSignerMutationOptions = Apollo.BaseMutationOptions<UpdateSignerMutation, UpdateSignerMutationVariables>;\nexport const ToggleWitnessSubscriptionAgreementDocument: TypedDocumentNode<ToggleWitnessSubscriptionAgreementMutation, ToggleWitnessSubscriptionAgreementMutationVariables> = gql`\n  mutation toggleWitnessSubscriptionAgreement($offerId: OrganisationRaiseOfferCakeType!, $requireWitness: Boolean!) {\n  toggleWitnessSubscriptionAgreement(\n    offer: $offerId\n    requireWitness: $requireWitness\n  )\n}\n    `;\nexport type ToggleWitnessSubscriptionAgreementMutationFn = Apollo.MutationFunction<ToggleWitnessSubscriptionAgreementMutation, ToggleWitnessSubscriptionAgreementMutationVariables>;\n\n/**\n * __useToggleWitnessSubscriptionAgreementMutation__\n *\n * To run a mutation, you first call `useToggleWitnessSubscriptionAgreementMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useToggleWitnessSubscriptionAgreementMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [toggleWitnessSubscriptionAgreementMutation, { data, loading, error }] = useToggleWitnessSubscriptionAgreementMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      requireWitness: // value for 'requireWitness'\n *   },\n * });\n */\nexport function useToggleWitnessSubscriptionAgreementMutation(baseOptions?: Apollo.MutationHookOptions<ToggleWitnessSubscriptionAgreementMutation, ToggleWitnessSubscriptionAgreementMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ToggleWitnessSubscriptionAgreementMutation, ToggleWitnessSubscriptionAgreementMutationVariables>(ToggleWitnessSubscriptionAgreementDocument, options);\n      }\nexport type ToggleWitnessSubscriptionAgreementMutationHookResult = ReturnType<typeof useToggleWitnessSubscriptionAgreementMutation>;\nexport type ToggleWitnessSubscriptionAgreementMutationResult = Apollo.MutationResult<ToggleWitnessSubscriptionAgreementMutation>;\nexport type ToggleWitnessSubscriptionAgreementMutationOptions = Apollo.BaseMutationOptions<ToggleWitnessSubscriptionAgreementMutation, ToggleWitnessSubscriptionAgreementMutationVariables>;\nexport const ToggleWitnessOfferNoteDocument: TypedDocumentNode<ToggleWitnessOfferNoteMutation, ToggleWitnessOfferNoteMutationVariables> = gql`\n  mutation toggleWitnessOfferNote($offerId: NotesRoundOfferCakeType!, $requireWitness: Boolean!) {\n  toggleWitnessOfferNote(offer: $offerId, requireWitness: $requireWitness)\n}\n    `;\nexport type ToggleWitnessOfferNoteMutationFn = Apollo.MutationFunction<ToggleWitnessOfferNoteMutation, ToggleWitnessOfferNoteMutationVariables>;\n\n/**\n * __useToggleWitnessOfferNoteMutation__\n *\n * To run a mutation, you first call `useToggleWitnessOfferNoteMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useToggleWitnessOfferNoteMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [toggleWitnessOfferNoteMutation, { data, loading, error }] = useToggleWitnessOfferNoteMutation({\n *   variables: {\n *      offerId: // value for 'offerId'\n *      requireWitness: // value for 'requireWitness'\n *   },\n * });\n */\nexport function useToggleWitnessOfferNoteMutation(baseOptions?: Apollo.MutationHookOptions<ToggleWitnessOfferNoteMutation, ToggleWitnessOfferNoteMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ToggleWitnessOfferNoteMutation, ToggleWitnessOfferNoteMutationVariables>(ToggleWitnessOfferNoteDocument, options);\n      }\nexport type ToggleWitnessOfferNoteMutationHookResult = ReturnType<typeof useToggleWitnessOfferNoteMutation>;\nexport type ToggleWitnessOfferNoteMutationResult = Apollo.MutationResult<ToggleWitnessOfferNoteMutation>;\nexport type ToggleWitnessOfferNoteMutationOptions = Apollo.BaseMutationOptions<ToggleWitnessOfferNoteMutation, ToggleWitnessOfferNoteMutationVariables>;\nexport const InvestorNotesDocument: TypedDocumentNode<InvestorNotesQuery, InvestorNotesQueryVariables> = gql`\n  query investorNotes($shareholder: ShareholderCakeType!) {\n  investorNotes(shareholder: $shareholder) {\n    id\n    resolution\n    noteType: type\n    principal\n    discountRate\n    maturityDate\n    interestRate\n    issueDate\n    valuationCap\n    shareholder {\n      displayName\n    }\n  }\n}\n    `;\n\n/**\n * __useInvestorNotesQuery__\n *\n * To run a query within a React component, call `useInvestorNotesQuery` and pass it any options that fit your needs.\n * When your component renders, `useInvestorNotesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useInvestorNotesQuery({\n *   variables: {\n *      shareholder: // value for 'shareholder'\n *   },\n * });\n */\nexport function useInvestorNotesQuery(baseOptions: Apollo.QueryHookOptions<InvestorNotesQuery, InvestorNotesQueryVariables> & ({ variables: InvestorNotesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<InvestorNotesQuery, InvestorNotesQueryVariables>(InvestorNotesDocument, options);\n      }\nexport function useInvestorNotesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<InvestorNotesQuery, InvestorNotesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<InvestorNotesQuery, InvestorNotesQueryVariables>(InvestorNotesDocument, options);\n        }\nexport function useInvestorNotesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<InvestorNotesQuery, InvestorNotesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<InvestorNotesQuery, InvestorNotesQueryVariables>(InvestorNotesDocument, options);\n        }\nexport type InvestorNotesQueryHookResult = ReturnType<typeof useInvestorNotesQuery>;\nexport type InvestorNotesLazyQueryHookResult = ReturnType<typeof useInvestorNotesLazyQuery>;\nexport type InvestorNotesSuspenseQueryHookResult = ReturnType<typeof useInvestorNotesSuspenseQuery>;\nexport type InvestorNotesQueryResult = Apollo.QueryResult<InvestorNotesQuery, InvestorNotesQueryVariables>;\nexport function refetchInvestorNotesQuery(variables: InvestorNotesQueryVariables) {\n      return { query: InvestorNotesDocument, variables: variables };\n    }\nexport const DeleteNoteDocument: TypedDocumentNode<DeleteNoteMutation, DeleteNoteMutationVariables> = gql`\n  mutation deleteNote($note: NoteCakeType!) {\n  deleteNote(note: $note)\n}\n    `;\nexport type DeleteNoteMutationFn = Apollo.MutationFunction<DeleteNoteMutation, DeleteNoteMutationVariables>;\n\n/**\n * __useDeleteNoteMutation__\n *\n * To run a mutation, you first call `useDeleteNoteMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteNoteMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteNoteMutation, { data, loading, error }] = useDeleteNoteMutation({\n *   variables: {\n *      note: // value for 'note'\n *   },\n * });\n */\nexport function useDeleteNoteMutation(baseOptions?: Apollo.MutationHookOptions<DeleteNoteMutation, DeleteNoteMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteNoteMutation, DeleteNoteMutationVariables>(DeleteNoteDocument, options);\n      }\nexport type DeleteNoteMutationHookResult = ReturnType<typeof useDeleteNoteMutation>;\nexport type DeleteNoteMutationResult = Apollo.MutationResult<DeleteNoteMutation>;\nexport type DeleteNoteMutationOptions = Apollo.BaseMutationOptions<DeleteNoteMutation, DeleteNoteMutationVariables>;\nexport const GetCaptableUsersDocument: TypedDocumentNode<GetCaptableUsersQuery, GetCaptableUsersQueryVariables> = gql`\n  query getCaptableUsers($organisationId: UUID!, $search: String, $excludeByIds: [UUID]) {\n  shareholders(\n    organisationId: $organisationId\n    search: $search\n    excludeByIds: $excludeByIds\n  ) {\n    id\n    displayName\n    investorData {\n      email\n    }\n    avatar\n  }\n  officeholders(\n    organisationId: $organisationId\n    search: $search\n    excludeByIds: $excludeByIds\n  ) {\n    id\n    name\n    email\n    avatar\n  }\n  cakeGroups(\n    organisationId: $organisationId\n    search: $search\n    excludeByIds: $excludeByIds\n  ) {\n    id\n    name\n    count\n    groupType\n  }\n}\n    `;\n\n/**\n * __useGetCaptableUsersQuery__\n *\n * To run a query within a React component, call `useGetCaptableUsersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetCaptableUsersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetCaptableUsersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      search: // value for 'search'\n *      excludeByIds: // value for 'excludeByIds'\n *   },\n * });\n */\nexport function useGetCaptableUsersQuery(baseOptions: Apollo.QueryHookOptions<GetCaptableUsersQuery, GetCaptableUsersQueryVariables> & ({ variables: GetCaptableUsersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetCaptableUsersQuery, GetCaptableUsersQueryVariables>(GetCaptableUsersDocument, options);\n      }\nexport function useGetCaptableUsersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetCaptableUsersQuery, GetCaptableUsersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetCaptableUsersQuery, GetCaptableUsersQueryVariables>(GetCaptableUsersDocument, options);\n        }\nexport function useGetCaptableUsersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetCaptableUsersQuery, GetCaptableUsersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetCaptableUsersQuery, GetCaptableUsersQueryVariables>(GetCaptableUsersDocument, options);\n        }\nexport type GetCaptableUsersQueryHookResult = ReturnType<typeof useGetCaptableUsersQuery>;\nexport type GetCaptableUsersLazyQueryHookResult = ReturnType<typeof useGetCaptableUsersLazyQuery>;\nexport type GetCaptableUsersSuspenseQueryHookResult = ReturnType<typeof useGetCaptableUsersSuspenseQuery>;\nexport type GetCaptableUsersQueryResult = Apollo.QueryResult<GetCaptableUsersQuery, GetCaptableUsersQueryVariables>;\nexport function refetchGetCaptableUsersQuery(variables: GetCaptableUsersQueryVariables) {\n      return { query: GetCaptableUsersDocument, variables: variables };\n    }\nexport const SendCaptableDocumentUploadEmailsDocument: TypedDocumentNode<SendCaptableDocumentUploadEmailsMutation, SendCaptableDocumentUploadEmailsMutationVariables> = gql`\n  mutation sendCaptableDocumentUploadEmails($organisation: OrganisationCakeType!) {\n  sendCaptableDocumentUploadEmails(organisation: $organisation)\n}\n    `;\nexport type SendCaptableDocumentUploadEmailsMutationFn = Apollo.MutationFunction<SendCaptableDocumentUploadEmailsMutation, SendCaptableDocumentUploadEmailsMutationVariables>;\n\n/**\n * __useSendCaptableDocumentUploadEmailsMutation__\n *\n * To run a mutation, you first call `useSendCaptableDocumentUploadEmailsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSendCaptableDocumentUploadEmailsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [sendCaptableDocumentUploadEmailsMutation, { data, loading, error }] = useSendCaptableDocumentUploadEmailsMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useSendCaptableDocumentUploadEmailsMutation(baseOptions?: Apollo.MutationHookOptions<SendCaptableDocumentUploadEmailsMutation, SendCaptableDocumentUploadEmailsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SendCaptableDocumentUploadEmailsMutation, SendCaptableDocumentUploadEmailsMutationVariables>(SendCaptableDocumentUploadEmailsDocument, options);\n      }\nexport type SendCaptableDocumentUploadEmailsMutationHookResult = ReturnType<typeof useSendCaptableDocumentUploadEmailsMutation>;\nexport type SendCaptableDocumentUploadEmailsMutationResult = Apollo.MutationResult<SendCaptableDocumentUploadEmailsMutation>;\nexport type SendCaptableDocumentUploadEmailsMutationOptions = Apollo.BaseMutationOptions<SendCaptableDocumentUploadEmailsMutation, SendCaptableDocumentUploadEmailsMutationVariables>;\nexport const IsCaptableSensitiveDocument: TypedDocumentNode<IsCaptableSensitiveQuery, IsCaptableSensitiveQueryVariables> = gql`\n  query isCaptableSensitive($sharetypeId: SharetypeCakeType!, $at: Date, $destructive: Boolean) {\n  isCaptableSensitive(\n    sharetype: $sharetypeId\n    at: $at\n    destructiveIntent: $destructive\n  )\n}\n    `;\n\n/**\n * __useIsCaptableSensitiveQuery__\n *\n * To run a query within a React component, call `useIsCaptableSensitiveQuery` and pass it any options that fit your needs.\n * When your component renders, `useIsCaptableSensitiveQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useIsCaptableSensitiveQuery({\n *   variables: {\n *      sharetypeId: // value for 'sharetypeId'\n *      at: // value for 'at'\n *      destructive: // value for 'destructive'\n *   },\n * });\n */\nexport function useIsCaptableSensitiveQuery(baseOptions: Apollo.QueryHookOptions<IsCaptableSensitiveQuery, IsCaptableSensitiveQueryVariables> & ({ variables: IsCaptableSensitiveQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<IsCaptableSensitiveQuery, IsCaptableSensitiveQueryVariables>(IsCaptableSensitiveDocument, options);\n      }\nexport function useIsCaptableSensitiveLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IsCaptableSensitiveQuery, IsCaptableSensitiveQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<IsCaptableSensitiveQuery, IsCaptableSensitiveQueryVariables>(IsCaptableSensitiveDocument, options);\n        }\nexport function useIsCaptableSensitiveSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<IsCaptableSensitiveQuery, IsCaptableSensitiveQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<IsCaptableSensitiveQuery, IsCaptableSensitiveQueryVariables>(IsCaptableSensitiveDocument, options);\n        }\nexport type IsCaptableSensitiveQueryHookResult = ReturnType<typeof useIsCaptableSensitiveQuery>;\nexport type IsCaptableSensitiveLazyQueryHookResult = ReturnType<typeof useIsCaptableSensitiveLazyQuery>;\nexport type IsCaptableSensitiveSuspenseQueryHookResult = ReturnType<typeof useIsCaptableSensitiveSuspenseQuery>;\nexport type IsCaptableSensitiveQueryResult = Apollo.QueryResult<IsCaptableSensitiveQuery, IsCaptableSensitiveQueryVariables>;\nexport function refetchIsCaptableSensitiveQuery(variables: IsCaptableSensitiveQueryVariables) {\n      return { query: IsCaptableSensitiveDocument, variables: variables };\n    }\nexport const OrganisationDocument: TypedDocumentNode<OrganisationQuery, OrganisationQueryVariables> = gql`\n  query organisation($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    totalSecurities\n    totalShares\n    sharetypeSet {\n      id\n      name\n      symbol\n    }\n  }\n}\n    `;\n\n/**\n * __useOrganisationQuery__\n *\n * To run a query within a React component, call `useOrganisationQuery` and pass it any options that fit your needs.\n * When your component renders, `useOrganisationQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOrganisationQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useOrganisationQuery(baseOptions: Apollo.QueryHookOptions<OrganisationQuery, OrganisationQueryVariables> & ({ variables: OrganisationQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OrganisationQuery, OrganisationQueryVariables>(OrganisationDocument, options);\n      }\nexport function useOrganisationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OrganisationQuery, OrganisationQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OrganisationQuery, OrganisationQueryVariables>(OrganisationDocument, options);\n        }\nexport function useOrganisationSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OrganisationQuery, OrganisationQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OrganisationQuery, OrganisationQueryVariables>(OrganisationDocument, options);\n        }\nexport type OrganisationQueryHookResult = ReturnType<typeof useOrganisationQuery>;\nexport type OrganisationLazyQueryHookResult = ReturnType<typeof useOrganisationLazyQuery>;\nexport type OrganisationSuspenseQueryHookResult = ReturnType<typeof useOrganisationSuspenseQuery>;\nexport type OrganisationQueryResult = Apollo.QueryResult<OrganisationQuery, OrganisationQueryVariables>;\nexport function refetchOrganisationQuery(variables: OrganisationQueryVariables) {\n      return { query: OrganisationDocument, variables: variables };\n    }\nexport const GetModelerSeedDataDocument: TypedDocumentNode<GetModelerSeedDataQuery, GetModelerSeedDataQueryVariables> = gql`\n  query getModelerSeedData($organisationId: OrganisationCakeType!, $organisationIdUuid: UUID!) {\n  dashboardOwnership(organisation: $organisationId) {\n    totalShares\n    valuation\n    topShareholders {\n      sid\n      name\n      number\n    }\n  }\n  dashboardEsopAggregate(organisation: $organisationId) {\n    totalOptions\n    exercised\n    allocated\n    unallocated\n  }\n  shareholdersWithNoteholdings(\n    organisationId: $organisationIdUuid\n    page: 1\n    itemsPerPage: 100\n  ) {\n    pageData {\n      displayName\n      notes {\n        id\n        resolution\n        noteType: type\n        principal\n        discountRate\n        maturityDate\n        interestRate\n        issueDate\n        valuationCap\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetModelerSeedDataQuery__\n *\n * To run a query within a React component, call `useGetModelerSeedDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetModelerSeedDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetModelerSeedDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      organisationIdUuid: // value for 'organisationIdUuid'\n *   },\n * });\n */\nexport function useGetModelerSeedDataQuery(baseOptions: Apollo.QueryHookOptions<GetModelerSeedDataQuery, GetModelerSeedDataQueryVariables> & ({ variables: GetModelerSeedDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetModelerSeedDataQuery, GetModelerSeedDataQueryVariables>(GetModelerSeedDataDocument, options);\n      }\nexport function useGetModelerSeedDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetModelerSeedDataQuery, GetModelerSeedDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetModelerSeedDataQuery, GetModelerSeedDataQueryVariables>(GetModelerSeedDataDocument, options);\n        }\nexport function useGetModelerSeedDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetModelerSeedDataQuery, GetModelerSeedDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetModelerSeedDataQuery, GetModelerSeedDataQueryVariables>(GetModelerSeedDataDocument, options);\n        }\nexport type GetModelerSeedDataQueryHookResult = ReturnType<typeof useGetModelerSeedDataQuery>;\nexport type GetModelerSeedDataLazyQueryHookResult = ReturnType<typeof useGetModelerSeedDataLazyQuery>;\nexport type GetModelerSeedDataSuspenseQueryHookResult = ReturnType<typeof useGetModelerSeedDataSuspenseQuery>;\nexport type GetModelerSeedDataQueryResult = Apollo.QueryResult<GetModelerSeedDataQuery, GetModelerSeedDataQueryVariables>;\nexport function refetchGetModelerSeedDataQuery(variables: GetModelerSeedDataQueryVariables) {\n      return { query: GetModelerSeedDataDocument, variables: variables };\n    }\nexport const IsTransactionEditableDocument: TypedDocumentNode<IsTransactionEditableQuery, IsTransactionEditableQueryVariables> = gql`\n  query isTransactionEditable($transactionId: ShareholdingTransactionCakeType!) {\n  isTransactionEditable(transaction: $transactionId)\n  transactionDetails(transaction: $transactionId) {\n    transactionId: id\n    transactionDate\n    transactionType: type\n    shares\n    amount\n    paidInTransfer\n    shareholder {\n      id\n      displayName\n      secondaryName\n    }\n    sharetype {\n      id\n      name\n      symbol\n    }\n  }\n}\n    `;\n\n/**\n * __useIsTransactionEditableQuery__\n *\n * To run a query within a React component, call `useIsTransactionEditableQuery` and pass it any options that fit your needs.\n * When your component renders, `useIsTransactionEditableQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useIsTransactionEditableQuery({\n *   variables: {\n *      transactionId: // value for 'transactionId'\n *   },\n * });\n */\nexport function useIsTransactionEditableQuery(baseOptions: Apollo.QueryHookOptions<IsTransactionEditableQuery, IsTransactionEditableQueryVariables> & ({ variables: IsTransactionEditableQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<IsTransactionEditableQuery, IsTransactionEditableQueryVariables>(IsTransactionEditableDocument, options);\n      }\nexport function useIsTransactionEditableLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IsTransactionEditableQuery, IsTransactionEditableQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<IsTransactionEditableQuery, IsTransactionEditableQueryVariables>(IsTransactionEditableDocument, options);\n        }\nexport function useIsTransactionEditableSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<IsTransactionEditableQuery, IsTransactionEditableQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<IsTransactionEditableQuery, IsTransactionEditableQueryVariables>(IsTransactionEditableDocument, options);\n        }\nexport type IsTransactionEditableQueryHookResult = ReturnType<typeof useIsTransactionEditableQuery>;\nexport type IsTransactionEditableLazyQueryHookResult = ReturnType<typeof useIsTransactionEditableLazyQuery>;\nexport type IsTransactionEditableSuspenseQueryHookResult = ReturnType<typeof useIsTransactionEditableSuspenseQuery>;\nexport type IsTransactionEditableQueryResult = Apollo.QueryResult<IsTransactionEditableQuery, IsTransactionEditableQueryVariables>;\nexport function refetchIsTransactionEditableQuery(variables: IsTransactionEditableQueryVariables) {\n      return { query: IsTransactionEditableDocument, variables: variables };\n    }\nexport const EditTransactionDocument: TypedDocumentNode<EditTransactionMutation, EditTransactionMutationVariables> = gql`\n  mutation editTransaction($transactionId: ShareholdingTransactionCakeType!, $shares: PositiveInteger, $amount: CakeDecimal, $transactionDate: Date) {\n  editTransaction(\n    shareholdingTransaction: $transactionId\n    shares: $shares\n    amount: $amount\n    transactionDate: $transactionDate\n  )\n}\n    `;\nexport type EditTransactionMutationFn = Apollo.MutationFunction<EditTransactionMutation, EditTransactionMutationVariables>;\n\n/**\n * __useEditTransactionMutation__\n *\n * To run a mutation, you first call `useEditTransactionMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditTransactionMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editTransactionMutation, { data, loading, error }] = useEditTransactionMutation({\n *   variables: {\n *      transactionId: // value for 'transactionId'\n *      shares: // value for 'shares'\n *      amount: // value for 'amount'\n *      transactionDate: // value for 'transactionDate'\n *   },\n * });\n */\nexport function useEditTransactionMutation(baseOptions?: Apollo.MutationHookOptions<EditTransactionMutation, EditTransactionMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditTransactionMutation, EditTransactionMutationVariables>(EditTransactionDocument, options);\n      }\nexport type EditTransactionMutationHookResult = ReturnType<typeof useEditTransactionMutation>;\nexport type EditTransactionMutationResult = Apollo.MutationResult<EditTransactionMutation>;\nexport type EditTransactionMutationOptions = Apollo.BaseMutationOptions<EditTransactionMutation, EditTransactionMutationVariables>;\nexport const ShareholdersReportDocument: TypedDocumentNode<ShareholdersReportQuery, ShareholdersReportQueryVariables> = gql`\n  query shareholdersReport($organisation: OrganisationCakeType!, $reportDate: Date!, $organisationId: UUID!) {\n  shareholdersReport(organisation: $organisation, reportDate: $reportDate) {\n    sharetypes {\n      id\n      symbol\n      name\n      hasPlans\n    }\n    shareholders {\n      id\n      displayName\n      shares\n      holdings {\n        sharetype\n        shares\n        unvestedShares\n      }\n    }\n    optionholders {\n      id\n      displayName\n      vestingValue\n      granted\n      vested\n      lapsed\n      exercised\n    }\n    rsuholders {\n      id\n      displayName\n      vestingValue\n      granted\n      vested\n      lapsed\n      exercised\n    }\n    unallocatedOptions\n    unallocatedShares\n    unallocatedRsus\n  }\n  organisation(organisationId: $organisationId) {\n    valuationAt(date: $reportDate) {\n      valuation\n    }\n  }\n}\n    `;\n\n/**\n * __useShareholdersReportQuery__\n *\n * To run a query within a React component, call `useShareholdersReportQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareholdersReportQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareholdersReportQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      reportDate: // value for 'reportDate'\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useShareholdersReportQuery(baseOptions: Apollo.QueryHookOptions<ShareholdersReportQuery, ShareholdersReportQueryVariables> & ({ variables: ShareholdersReportQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareholdersReportQuery, ShareholdersReportQueryVariables>(ShareholdersReportDocument, options);\n      }\nexport function useShareholdersReportLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareholdersReportQuery, ShareholdersReportQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareholdersReportQuery, ShareholdersReportQueryVariables>(ShareholdersReportDocument, options);\n        }\nexport function useShareholdersReportSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareholdersReportQuery, ShareholdersReportQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareholdersReportQuery, ShareholdersReportQueryVariables>(ShareholdersReportDocument, options);\n        }\nexport type ShareholdersReportQueryHookResult = ReturnType<typeof useShareholdersReportQuery>;\nexport type ShareholdersReportLazyQueryHookResult = ReturnType<typeof useShareholdersReportLazyQuery>;\nexport type ShareholdersReportSuspenseQueryHookResult = ReturnType<typeof useShareholdersReportSuspenseQuery>;\nexport type ShareholdersReportQueryResult = Apollo.QueryResult<ShareholdersReportQuery, ShareholdersReportQueryVariables>;\nexport function refetchShareholdersReportQuery(variables: ShareholdersReportQueryVariables) {\n      return { query: ShareholdersReportDocument, variables: variables };\n    }\nexport const GetOrganisationDataBasicDocument: TypedDocumentNode<GetOrganisationDataBasicQuery, GetOrganisationDataBasicQueryVariables> = gql`\n  query getOrganisationDataBasic($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    name\n    logoImage\n  }\n}\n    `;\n\n/**\n * __useGetOrganisationDataBasicQuery__\n *\n * To run a query within a React component, call `useGetOrganisationDataBasicQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetOrganisationDataBasicQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetOrganisationDataBasicQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetOrganisationDataBasicQuery(baseOptions: Apollo.QueryHookOptions<GetOrganisationDataBasicQuery, GetOrganisationDataBasicQueryVariables> & ({ variables: GetOrganisationDataBasicQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetOrganisationDataBasicQuery, GetOrganisationDataBasicQueryVariables>(GetOrganisationDataBasicDocument, options);\n      }\nexport function useGetOrganisationDataBasicLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetOrganisationDataBasicQuery, GetOrganisationDataBasicQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetOrganisationDataBasicQuery, GetOrganisationDataBasicQueryVariables>(GetOrganisationDataBasicDocument, options);\n        }\nexport function useGetOrganisationDataBasicSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetOrganisationDataBasicQuery, GetOrganisationDataBasicQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetOrganisationDataBasicQuery, GetOrganisationDataBasicQueryVariables>(GetOrganisationDataBasicDocument, options);\n        }\nexport type GetOrganisationDataBasicQueryHookResult = ReturnType<typeof useGetOrganisationDataBasicQuery>;\nexport type GetOrganisationDataBasicLazyQueryHookResult = ReturnType<typeof useGetOrganisationDataBasicLazyQuery>;\nexport type GetOrganisationDataBasicSuspenseQueryHookResult = ReturnType<typeof useGetOrganisationDataBasicSuspenseQuery>;\nexport type GetOrganisationDataBasicQueryResult = Apollo.QueryResult<GetOrganisationDataBasicQuery, GetOrganisationDataBasicQueryVariables>;\nexport function refetchGetOrganisationDataBasicQuery(variables: GetOrganisationDataBasicQueryVariables) {\n      return { query: GetOrganisationDataBasicDocument, variables: variables };\n    }\nexport const EditOnboardedShareholdersDocument: TypedDocumentNode<EditOnboardedShareholdersMutation, EditOnboardedShareholdersMutationVariables> = gql`\n  mutation editOnboardedShareholders($organisation: OrganisationCakeType!, $shareholderIssueSharesInputList: [ShareholderIssueSharesInput!]!) {\n  editOnboardedShareholders(\n    organisation: $organisation\n    shareholderIssueSharesInputList: $shareholderIssueSharesInputList\n  )\n}\n    `;\nexport type EditOnboardedShareholdersMutationFn = Apollo.MutationFunction<EditOnboardedShareholdersMutation, EditOnboardedShareholdersMutationVariables>;\n\n/**\n * __useEditOnboardedShareholdersMutation__\n *\n * To run a mutation, you first call `useEditOnboardedShareholdersMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditOnboardedShareholdersMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editOnboardedShareholdersMutation, { data, loading, error }] = useEditOnboardedShareholdersMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      shareholderIssueSharesInputList: // value for 'shareholderIssueSharesInputList'\n *   },\n * });\n */\nexport function useEditOnboardedShareholdersMutation(baseOptions?: Apollo.MutationHookOptions<EditOnboardedShareholdersMutation, EditOnboardedShareholdersMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditOnboardedShareholdersMutation, EditOnboardedShareholdersMutationVariables>(EditOnboardedShareholdersDocument, options);\n      }\nexport type EditOnboardedShareholdersMutationHookResult = ReturnType<typeof useEditOnboardedShareholdersMutation>;\nexport type EditOnboardedShareholdersMutationResult = Apollo.MutationResult<EditOnboardedShareholdersMutation>;\nexport type EditOnboardedShareholdersMutationOptions = Apollo.BaseMutationOptions<EditOnboardedShareholdersMutation, EditOnboardedShareholdersMutationVariables>;\nexport const GetTrusteesDocument: TypedDocumentNode<GetTrusteesQuery, GetTrusteesQueryVariables> = gql`\n  query getTrustees($organisationId: OrganisationCakeType!, $search: CleanString) {\n  getTrustees(organisation: $organisationId, search: $search) {\n    id\n    displayName\n    avatar\n    secondaryName\n    trustName\n    recipient {\n      id\n      displayName\n    }\n    investorData {\n      name\n      email\n      companyData {\n        contactPerson\n      }\n      address {\n        country\n        administrativeArea1\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetTrusteesQuery__\n *\n * To run a query within a React component, call `useGetTrusteesQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetTrusteesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetTrusteesQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetTrusteesQuery(baseOptions: Apollo.QueryHookOptions<GetTrusteesQuery, GetTrusteesQueryVariables> & ({ variables: GetTrusteesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetTrusteesQuery, GetTrusteesQueryVariables>(GetTrusteesDocument, options);\n      }\nexport function useGetTrusteesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetTrusteesQuery, GetTrusteesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetTrusteesQuery, GetTrusteesQueryVariables>(GetTrusteesDocument, options);\n        }\nexport function useGetTrusteesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetTrusteesQuery, GetTrusteesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetTrusteesQuery, GetTrusteesQueryVariables>(GetTrusteesDocument, options);\n        }\nexport type GetTrusteesQueryHookResult = ReturnType<typeof useGetTrusteesQuery>;\nexport type GetTrusteesLazyQueryHookResult = ReturnType<typeof useGetTrusteesLazyQuery>;\nexport type GetTrusteesSuspenseQueryHookResult = ReturnType<typeof useGetTrusteesSuspenseQuery>;\nexport type GetTrusteesQueryResult = Apollo.QueryResult<GetTrusteesQuery, GetTrusteesQueryVariables>;\nexport function refetchGetTrusteesQuery(variables: GetTrusteesQueryVariables) {\n      return { query: GetTrusteesDocument, variables: variables };\n    }\nexport const GetUserPreferenceDocument: TypedDocumentNode<GetUserPreferenceQuery, GetUserPreferenceQueryVariables> = gql`\n  query getUserPreference($organisationId: OrganisationCakeType!, $name: String!, $defaultValue: Boolean) {\n  userPreference(\n    organisation: $organisationId\n    name: $name\n    default: $defaultValue\n  )\n}\n    `;\n\n/**\n * __useGetUserPreferenceQuery__\n *\n * To run a query within a React component, call `useGetUserPreferenceQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetUserPreferenceQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetUserPreferenceQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      name: // value for 'name'\n *      defaultValue: // value for 'defaultValue'\n *   },\n * });\n */\nexport function useGetUserPreferenceQuery(baseOptions: Apollo.QueryHookOptions<GetUserPreferenceQuery, GetUserPreferenceQueryVariables> & ({ variables: GetUserPreferenceQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetUserPreferenceQuery, GetUserPreferenceQueryVariables>(GetUserPreferenceDocument, options);\n      }\nexport function useGetUserPreferenceLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetUserPreferenceQuery, GetUserPreferenceQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetUserPreferenceQuery, GetUserPreferenceQueryVariables>(GetUserPreferenceDocument, options);\n        }\nexport function useGetUserPreferenceSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetUserPreferenceQuery, GetUserPreferenceQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetUserPreferenceQuery, GetUserPreferenceQueryVariables>(GetUserPreferenceDocument, options);\n        }\nexport type GetUserPreferenceQueryHookResult = ReturnType<typeof useGetUserPreferenceQuery>;\nexport type GetUserPreferenceLazyQueryHookResult = ReturnType<typeof useGetUserPreferenceLazyQuery>;\nexport type GetUserPreferenceSuspenseQueryHookResult = ReturnType<typeof useGetUserPreferenceSuspenseQuery>;\nexport type GetUserPreferenceQueryResult = Apollo.QueryResult<GetUserPreferenceQuery, GetUserPreferenceQueryVariables>;\nexport function refetchGetUserPreferenceQuery(variables: GetUserPreferenceQueryVariables) {\n      return { query: GetUserPreferenceDocument, variables: variables };\n    }\nexport const SetUserPreferenceDocument: TypedDocumentNode<SetUserPreferenceMutation, SetUserPreferenceMutationVariables> = gql`\n  mutation setUserPreference($organisationId: OrganisationCakeType!, $name: String!, $value: Boolean!) {\n  setUserPreference(organisation: $organisationId, name: $name, value: $value)\n}\n    `;\nexport type SetUserPreferenceMutationFn = Apollo.MutationFunction<SetUserPreferenceMutation, SetUserPreferenceMutationVariables>;\n\n/**\n * __useSetUserPreferenceMutation__\n *\n * To run a mutation, you first call `useSetUserPreferenceMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSetUserPreferenceMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [setUserPreferenceMutation, { data, loading, error }] = useSetUserPreferenceMutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      name: // value for 'name'\n *      value: // value for 'value'\n *   },\n * });\n */\nexport function useSetUserPreferenceMutation(baseOptions?: Apollo.MutationHookOptions<SetUserPreferenceMutation, SetUserPreferenceMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SetUserPreferenceMutation, SetUserPreferenceMutationVariables>(SetUserPreferenceDocument, options);\n      }\nexport type SetUserPreferenceMutationHookResult = ReturnType<typeof useSetUserPreferenceMutation>;\nexport type SetUserPreferenceMutationResult = Apollo.MutationResult<SetUserPreferenceMutation>;\nexport type SetUserPreferenceMutationOptions = Apollo.BaseMutationOptions<SetUserPreferenceMutation, SetUserPreferenceMutationVariables>;\nexport const GetChecklistDocument: TypedDocumentNode<GetChecklistQuery, GetChecklistQueryVariables> = gql`\n  query getChecklist($organisationId: OrganisationCakeType!) {\n  getChecklist(organisation: $organisationId) {\n    key\n    title\n    description\n    completed\n    recommended\n    userPreference\n  }\n}\n    `;\n\n/**\n * __useGetChecklistQuery__\n *\n * To run a query within a React component, call `useGetChecklistQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetChecklistQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetChecklistQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetChecklistQuery(baseOptions: Apollo.QueryHookOptions<GetChecklistQuery, GetChecklistQueryVariables> & ({ variables: GetChecklistQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetChecklistQuery, GetChecklistQueryVariables>(GetChecklistDocument, options);\n      }\nexport function useGetChecklistLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetChecklistQuery, GetChecklistQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetChecklistQuery, GetChecklistQueryVariables>(GetChecklistDocument, options);\n        }\nexport function useGetChecklistSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetChecklistQuery, GetChecklistQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetChecklistQuery, GetChecklistQueryVariables>(GetChecklistDocument, options);\n        }\nexport type GetChecklistQueryHookResult = ReturnType<typeof useGetChecklistQuery>;\nexport type GetChecklistLazyQueryHookResult = ReturnType<typeof useGetChecklistLazyQuery>;\nexport type GetChecklistSuspenseQueryHookResult = ReturnType<typeof useGetChecklistSuspenseQuery>;\nexport type GetChecklistQueryResult = Apollo.QueryResult<GetChecklistQuery, GetChecklistQueryVariables>;\nexport function refetchGetChecklistQuery(variables: GetChecklistQueryVariables) {\n      return { query: GetChecklistDocument, variables: variables };\n    }\nexport const GetMainMenuDataDocument: TypedDocumentNode<GetMainMenuDataQuery, GetMainMenuDataQueryVariables> = gql`\n  query getMainMenuData($organisationId: UUID!, $organisation: OrganisationCakeType!, $addon: CleanString!) {\n  organisation(organisationId: $organisationId) {\n    hasGrantedEsopOffers\n    hasEsopPlans\n    hasEssPlans\n    hasRsuPlans\n    hasValuation\n    uploadInProgress\n    showOnboarding\n    creationIntents\n  }\n  organisationDocuments(\n    organisationId: $organisationId\n    filterType: \"PROCESSING\"\n    search: \"\"\n    page: 1\n    itemsPerPage: 1\n  ) {\n    count\n  }\n  price409A: getOneTimeAddonPrice(organisation: $organisation, cakeAddon: $addon)\n  actionItems(organisation: $organisation) {\n    count\n  }\n}\n    `;\n\n/**\n * __useGetMainMenuDataQuery__\n *\n * To run a query within a React component, call `useGetMainMenuDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetMainMenuDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetMainMenuDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      organisation: // value for 'organisation'\n *      addon: // value for 'addon'\n *   },\n * });\n */\nexport function useGetMainMenuDataQuery(baseOptions: Apollo.QueryHookOptions<GetMainMenuDataQuery, GetMainMenuDataQueryVariables> & ({ variables: GetMainMenuDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetMainMenuDataQuery, GetMainMenuDataQueryVariables>(GetMainMenuDataDocument, options);\n      }\nexport function useGetMainMenuDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetMainMenuDataQuery, GetMainMenuDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetMainMenuDataQuery, GetMainMenuDataQueryVariables>(GetMainMenuDataDocument, options);\n        }\nexport function useGetMainMenuDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetMainMenuDataQuery, GetMainMenuDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetMainMenuDataQuery, GetMainMenuDataQueryVariables>(GetMainMenuDataDocument, options);\n        }\nexport type GetMainMenuDataQueryHookResult = ReturnType<typeof useGetMainMenuDataQuery>;\nexport type GetMainMenuDataLazyQueryHookResult = ReturnType<typeof useGetMainMenuDataLazyQuery>;\nexport type GetMainMenuDataSuspenseQueryHookResult = ReturnType<typeof useGetMainMenuDataSuspenseQuery>;\nexport type GetMainMenuDataQueryResult = Apollo.QueryResult<GetMainMenuDataQuery, GetMainMenuDataQueryVariables>;\nexport function refetchGetMainMenuDataQuery(variables: GetMainMenuDataQueryVariables) {\n      return { query: GetMainMenuDataDocument, variables: variables };\n    }\nexport const GetNeedsOnboardingDocument: TypedDocumentNode<GetNeedsOnboardingQuery, GetNeedsOnboardingQueryVariables> = gql`\n  query getNeedsOnboarding($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    showOnboarding\n    creationIntents\n  }\n}\n    `;\n\n/**\n * __useGetNeedsOnboardingQuery__\n *\n * To run a query within a React component, call `useGetNeedsOnboardingQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetNeedsOnboardingQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetNeedsOnboardingQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetNeedsOnboardingQuery(baseOptions: Apollo.QueryHookOptions<GetNeedsOnboardingQuery, GetNeedsOnboardingQueryVariables> & ({ variables: GetNeedsOnboardingQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetNeedsOnboardingQuery, GetNeedsOnboardingQueryVariables>(GetNeedsOnboardingDocument, options);\n      }\nexport function useGetNeedsOnboardingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNeedsOnboardingQuery, GetNeedsOnboardingQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetNeedsOnboardingQuery, GetNeedsOnboardingQueryVariables>(GetNeedsOnboardingDocument, options);\n        }\nexport function useGetNeedsOnboardingSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetNeedsOnboardingQuery, GetNeedsOnboardingQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetNeedsOnboardingQuery, GetNeedsOnboardingQueryVariables>(GetNeedsOnboardingDocument, options);\n        }\nexport type GetNeedsOnboardingQueryHookResult = ReturnType<typeof useGetNeedsOnboardingQuery>;\nexport type GetNeedsOnboardingLazyQueryHookResult = ReturnType<typeof useGetNeedsOnboardingLazyQuery>;\nexport type GetNeedsOnboardingSuspenseQueryHookResult = ReturnType<typeof useGetNeedsOnboardingSuspenseQuery>;\nexport type GetNeedsOnboardingQueryResult = Apollo.QueryResult<GetNeedsOnboardingQuery, GetNeedsOnboardingQueryVariables>;\nexport function refetchGetNeedsOnboardingQuery(variables: GetNeedsOnboardingQueryVariables) {\n      return { query: GetNeedsOnboardingDocument, variables: variables };\n    }\nexport const GetBeginnerMenuDataDocument: TypedDocumentNode<GetBeginnerMenuDataQuery, GetBeginnerMenuDataQueryVariables> = gql`\n  query getBeginnerMenuData($organisationId: UUID!, $organisation: OrganisationCakeType!) {\n  organisation(organisationId: $organisationId) {\n    hasValuation\n    uploadInProgress\n  }\n  organisationDocuments(\n    organisationId: $organisationId\n    filterType: \"PROCESSING\"\n    search: \"\"\n    page: 1\n    itemsPerPage: 1\n  ) {\n    count\n  }\n  actionItems(organisation: $organisation) {\n    count\n  }\n}\n    `;\n\n/**\n * __useGetBeginnerMenuDataQuery__\n *\n * To run a query within a React component, call `useGetBeginnerMenuDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetBeginnerMenuDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetBeginnerMenuDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useGetBeginnerMenuDataQuery(baseOptions: Apollo.QueryHookOptions<GetBeginnerMenuDataQuery, GetBeginnerMenuDataQueryVariables> & ({ variables: GetBeginnerMenuDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetBeginnerMenuDataQuery, GetBeginnerMenuDataQueryVariables>(GetBeginnerMenuDataDocument, options);\n      }\nexport function useGetBeginnerMenuDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetBeginnerMenuDataQuery, GetBeginnerMenuDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetBeginnerMenuDataQuery, GetBeginnerMenuDataQueryVariables>(GetBeginnerMenuDataDocument, options);\n        }\nexport function useGetBeginnerMenuDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetBeginnerMenuDataQuery, GetBeginnerMenuDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetBeginnerMenuDataQuery, GetBeginnerMenuDataQueryVariables>(GetBeginnerMenuDataDocument, options);\n        }\nexport type GetBeginnerMenuDataQueryHookResult = ReturnType<typeof useGetBeginnerMenuDataQuery>;\nexport type GetBeginnerMenuDataLazyQueryHookResult = ReturnType<typeof useGetBeginnerMenuDataLazyQuery>;\nexport type GetBeginnerMenuDataSuspenseQueryHookResult = ReturnType<typeof useGetBeginnerMenuDataSuspenseQuery>;\nexport type GetBeginnerMenuDataQueryResult = Apollo.QueryResult<GetBeginnerMenuDataQuery, GetBeginnerMenuDataQueryVariables>;\nexport function refetchGetBeginnerMenuDataQuery(variables: GetBeginnerMenuDataQueryVariables) {\n      return { query: GetBeginnerMenuDataDocument, variables: variables };\n    }\nexport const GetDataToCreateVestablePlanDocument: TypedDocumentNode<GetDataToCreateVestablePlanQuery, GetDataToCreateVestablePlanQueryVariables> = gql`\n  query getDataToCreateVestablePlan($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    totalSecurities\n    sharetypeSet {\n      id\n      name\n      symbol\n    }\n    totalSharesUnexercised\n    totalShares\n    totalSecurities\n  }\n}\n    `;\n\n/**\n * __useGetDataToCreateVestablePlanQuery__\n *\n * To run a query within a React component, call `useGetDataToCreateVestablePlanQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDataToCreateVestablePlanQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDataToCreateVestablePlanQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetDataToCreateVestablePlanQuery(baseOptions: Apollo.QueryHookOptions<GetDataToCreateVestablePlanQuery, GetDataToCreateVestablePlanQueryVariables> & ({ variables: GetDataToCreateVestablePlanQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDataToCreateVestablePlanQuery, GetDataToCreateVestablePlanQueryVariables>(GetDataToCreateVestablePlanDocument, options);\n      }\nexport function useGetDataToCreateVestablePlanLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDataToCreateVestablePlanQuery, GetDataToCreateVestablePlanQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDataToCreateVestablePlanQuery, GetDataToCreateVestablePlanQueryVariables>(GetDataToCreateVestablePlanDocument, options);\n        }\nexport function useGetDataToCreateVestablePlanSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDataToCreateVestablePlanQuery, GetDataToCreateVestablePlanQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDataToCreateVestablePlanQuery, GetDataToCreateVestablePlanQueryVariables>(GetDataToCreateVestablePlanDocument, options);\n        }\nexport type GetDataToCreateVestablePlanQueryHookResult = ReturnType<typeof useGetDataToCreateVestablePlanQuery>;\nexport type GetDataToCreateVestablePlanLazyQueryHookResult = ReturnType<typeof useGetDataToCreateVestablePlanLazyQuery>;\nexport type GetDataToCreateVestablePlanSuspenseQueryHookResult = ReturnType<typeof useGetDataToCreateVestablePlanSuspenseQuery>;\nexport type GetDataToCreateVestablePlanQueryResult = Apollo.QueryResult<GetDataToCreateVestablePlanQuery, GetDataToCreateVestablePlanQueryVariables>;\nexport function refetchGetDataToCreateVestablePlanQuery(variables: GetDataToCreateVestablePlanQueryVariables) {\n      return { query: GetDataToCreateVestablePlanDocument, variables: variables };\n    }\nexport const GetNotSignedUpStakeholdersDocument: TypedDocumentNode<GetNotSignedUpStakeholdersQuery, GetNotSignedUpStakeholdersQueryVariables> = gql`\n  query getNotSignedUpStakeholders($organisationId: OrganisationCakeType!, $holdingsType: HoldingsType!, $holdingsContext: UUID) {\n  notSignedUpShareholders(\n    organisation: $organisationId\n    holdingsType: $holdingsType\n    holdingsContext: $holdingsContext\n  ) {\n    results {\n      id\n      name\n      email\n      consideredInvited\n    }\n    notSignedUpCount\n  }\n}\n    `;\n\n/**\n * __useGetNotSignedUpStakeholdersQuery__\n *\n * To run a query within a React component, call `useGetNotSignedUpStakeholdersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetNotSignedUpStakeholdersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetNotSignedUpStakeholdersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      holdingsType: // value for 'holdingsType'\n *      holdingsContext: // value for 'holdingsContext'\n *   },\n * });\n */\nexport function useGetNotSignedUpStakeholdersQuery(baseOptions: Apollo.QueryHookOptions<GetNotSignedUpStakeholdersQuery, GetNotSignedUpStakeholdersQueryVariables> & ({ variables: GetNotSignedUpStakeholdersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetNotSignedUpStakeholdersQuery, GetNotSignedUpStakeholdersQueryVariables>(GetNotSignedUpStakeholdersDocument, options);\n      }\nexport function useGetNotSignedUpStakeholdersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetNotSignedUpStakeholdersQuery, GetNotSignedUpStakeholdersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetNotSignedUpStakeholdersQuery, GetNotSignedUpStakeholdersQueryVariables>(GetNotSignedUpStakeholdersDocument, options);\n        }\nexport function useGetNotSignedUpStakeholdersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetNotSignedUpStakeholdersQuery, GetNotSignedUpStakeholdersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetNotSignedUpStakeholdersQuery, GetNotSignedUpStakeholdersQueryVariables>(GetNotSignedUpStakeholdersDocument, options);\n        }\nexport type GetNotSignedUpStakeholdersQueryHookResult = ReturnType<typeof useGetNotSignedUpStakeholdersQuery>;\nexport type GetNotSignedUpStakeholdersLazyQueryHookResult = ReturnType<typeof useGetNotSignedUpStakeholdersLazyQuery>;\nexport type GetNotSignedUpStakeholdersSuspenseQueryHookResult = ReturnType<typeof useGetNotSignedUpStakeholdersSuspenseQuery>;\nexport type GetNotSignedUpStakeholdersQueryResult = Apollo.QueryResult<GetNotSignedUpStakeholdersQuery, GetNotSignedUpStakeholdersQueryVariables>;\nexport function refetchGetNotSignedUpStakeholdersQuery(variables: GetNotSignedUpStakeholdersQueryVariables) {\n      return { query: GetNotSignedUpStakeholdersDocument, variables: variables };\n    }\nexport const GetShareholdersOverviewPageDataDocument: TypedDocumentNode<GetShareholdersOverviewPageDataQuery, GetShareholdersOverviewPageDataQueryVariables> = gql`\n  query getShareholdersOverviewPageData($organisationId: UUID!, $organisation: OrganisationCakeType!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $trust: ShareholderCakeType, $diluted: Boolean, $search: CleanString) {\n  shareholdersOverview(\n    organisation: $organisation\n    page: $page\n    itemsPerPage: $itemsPerPage\n    trust: $trust\n    diluted: $diluted\n    search: $search\n  ) {\n    pageData {\n      id\n      displayName\n      avatar\n      email\n      secondaryName\n      stakeholderType\n      consideredInvited\n      hasLoggedIn\n      sharetypeHoldings {\n        id\n        symbol\n        name\n        shares\n        weight\n        unvestedShares\n      }\n      isTrust\n      totalVestedOptions\n      totalUnvestedOptions\n      totalVestedRsus\n      totalUnvestedRsus\n      totalSecurities\n      totalShares\n      totalSafeNotesInvestment\n      totalConvertibleNotesInvestment\n    }\n    currentPage\n    count\n  }\n  organisation(organisationId: $organisationId) {\n    totalShares\n    fullyDilutedShares\n    logoImage\n    name\n    valuationAt {\n      valuation\n    }\n    hasEsopPlans\n    hasEssPlans\n    hasRsuPlans\n    hasSafeNotes\n    hasConNotes\n    hasFounderVestingPlans\n  }\n  sharetypes(organisationId: $organisationId) {\n    id\n    symbol\n    weight\n    totals {\n      totalShares\n    }\n  }\n}\n    `;\n\n/**\n * __useGetShareholdersOverviewPageDataQuery__\n *\n * To run a query within a React component, call `useGetShareholdersOverviewPageDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetShareholdersOverviewPageDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetShareholdersOverviewPageDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      organisation: // value for 'organisation'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      trust: // value for 'trust'\n *      diluted: // value for 'diluted'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetShareholdersOverviewPageDataQuery(baseOptions: Apollo.QueryHookOptions<GetShareholdersOverviewPageDataQuery, GetShareholdersOverviewPageDataQueryVariables> & ({ variables: GetShareholdersOverviewPageDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetShareholdersOverviewPageDataQuery, GetShareholdersOverviewPageDataQueryVariables>(GetShareholdersOverviewPageDataDocument, options);\n      }\nexport function useGetShareholdersOverviewPageDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetShareholdersOverviewPageDataQuery, GetShareholdersOverviewPageDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetShareholdersOverviewPageDataQuery, GetShareholdersOverviewPageDataQueryVariables>(GetShareholdersOverviewPageDataDocument, options);\n        }\nexport function useGetShareholdersOverviewPageDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetShareholdersOverviewPageDataQuery, GetShareholdersOverviewPageDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetShareholdersOverviewPageDataQuery, GetShareholdersOverviewPageDataQueryVariables>(GetShareholdersOverviewPageDataDocument, options);\n        }\nexport type GetShareholdersOverviewPageDataQueryHookResult = ReturnType<typeof useGetShareholdersOverviewPageDataQuery>;\nexport type GetShareholdersOverviewPageDataLazyQueryHookResult = ReturnType<typeof useGetShareholdersOverviewPageDataLazyQuery>;\nexport type GetShareholdersOverviewPageDataSuspenseQueryHookResult = ReturnType<typeof useGetShareholdersOverviewPageDataSuspenseQuery>;\nexport type GetShareholdersOverviewPageDataQueryResult = Apollo.QueryResult<GetShareholdersOverviewPageDataQuery, GetShareholdersOverviewPageDataQueryVariables>;\nexport function refetchGetShareholdersOverviewPageDataQuery(variables: GetShareholdersOverviewPageDataQueryVariables) {\n      return { query: GetShareholdersOverviewPageDataDocument, variables: variables };\n    }\nexport const GetTotalSecuritiesBreakdownDocument: TypedDocumentNode<GetTotalSecuritiesBreakdownQuery, GetTotalSecuritiesBreakdownQueryVariables> = gql`\n  query getTotalSecuritiesBreakdown($organisationId: OrganisationCakeType!) {\n  shareholdersSecuritiesBreakdown(organisation: $organisationId) {\n    sharetypeHoldings {\n      name\n      shares\n    }\n    totalUnallocatedShares\n    totalOfferedRsus\n    totalUnallocatedRsus\n    totalNotesInvestment\n  }\n}\n    `;\n\n/**\n * __useGetTotalSecuritiesBreakdownQuery__\n *\n * To run a query within a React component, call `useGetTotalSecuritiesBreakdownQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetTotalSecuritiesBreakdownQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetTotalSecuritiesBreakdownQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetTotalSecuritiesBreakdownQuery(baseOptions: Apollo.QueryHookOptions<GetTotalSecuritiesBreakdownQuery, GetTotalSecuritiesBreakdownQueryVariables> & ({ variables: GetTotalSecuritiesBreakdownQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetTotalSecuritiesBreakdownQuery, GetTotalSecuritiesBreakdownQueryVariables>(GetTotalSecuritiesBreakdownDocument, options);\n      }\nexport function useGetTotalSecuritiesBreakdownLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetTotalSecuritiesBreakdownQuery, GetTotalSecuritiesBreakdownQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetTotalSecuritiesBreakdownQuery, GetTotalSecuritiesBreakdownQueryVariables>(GetTotalSecuritiesBreakdownDocument, options);\n        }\nexport function useGetTotalSecuritiesBreakdownSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetTotalSecuritiesBreakdownQuery, GetTotalSecuritiesBreakdownQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetTotalSecuritiesBreakdownQuery, GetTotalSecuritiesBreakdownQueryVariables>(GetTotalSecuritiesBreakdownDocument, options);\n        }\nexport type GetTotalSecuritiesBreakdownQueryHookResult = ReturnType<typeof useGetTotalSecuritiesBreakdownQuery>;\nexport type GetTotalSecuritiesBreakdownLazyQueryHookResult = ReturnType<typeof useGetTotalSecuritiesBreakdownLazyQuery>;\nexport type GetTotalSecuritiesBreakdownSuspenseQueryHookResult = ReturnType<typeof useGetTotalSecuritiesBreakdownSuspenseQuery>;\nexport type GetTotalSecuritiesBreakdownQueryResult = Apollo.QueryResult<GetTotalSecuritiesBreakdownQuery, GetTotalSecuritiesBreakdownQueryVariables>;\nexport function refetchGetTotalSecuritiesBreakdownQuery(variables: GetTotalSecuritiesBreakdownQueryVariables) {\n      return { query: GetTotalSecuritiesBreakdownDocument, variables: variables };\n    }\nexport const GenerateUsIrsForm3921Document: TypedDocumentNode<GenerateUsIrsForm3921Mutation, GenerateUsIrsForm3921MutationVariables> = gql`\n  mutation generateUsIrsForm3921($organisationId: OrganisationCakeType!) {\n  generateUsIrsForm3921(organisation: $organisationId)\n}\n    `;\nexport type GenerateUsIrsForm3921MutationFn = Apollo.MutationFunction<GenerateUsIrsForm3921Mutation, GenerateUsIrsForm3921MutationVariables>;\n\n/**\n * __useGenerateUsIrsForm3921Mutation__\n *\n * To run a mutation, you first call `useGenerateUsIrsForm3921Mutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useGenerateUsIrsForm3921Mutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [generateUsIrsForm3921Mutation, { data, loading, error }] = useGenerateUsIrsForm3921Mutation({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGenerateUsIrsForm3921Mutation(baseOptions?: Apollo.MutationHookOptions<GenerateUsIrsForm3921Mutation, GenerateUsIrsForm3921MutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<GenerateUsIrsForm3921Mutation, GenerateUsIrsForm3921MutationVariables>(GenerateUsIrsForm3921Document, options);\n      }\nexport type GenerateUsIrsForm3921MutationHookResult = ReturnType<typeof useGenerateUsIrsForm3921Mutation>;\nexport type GenerateUsIrsForm3921MutationResult = Apollo.MutationResult<GenerateUsIrsForm3921Mutation>;\nexport type GenerateUsIrsForm3921MutationOptions = Apollo.BaseMutationOptions<GenerateUsIrsForm3921Mutation, GenerateUsIrsForm3921MutationVariables>;\nexport const GetShareholdersFullDataDocument: TypedDocumentNode<GetShareholdersFullDataQuery, GetShareholdersFullDataQueryVariables> = gql`\n  query getShareholdersFullData($organisationId: UUID!, $organisation: OrganisationCakeType!, $shareholderId: UUID!, $shareholder: ShareholderCakeType!, $isTrust: Boolean!) {\n  shareholderTransactions(shareholderId: $shareholderId) {\n    id\n    displayName\n    avatar\n    trustAbn\n    heldInTrust\n    trustName\n    comments\n    identificationCode\n    trust {\n      id\n      name\n    }\n    recipient {\n      id\n      displayName\n    }\n    investorData {\n      name\n      email\n      phone\n      jointIndex\n      address {\n        line2\n        line1\n        locality\n        administrativeArea1\n        postcode\n        country\n      }\n      companyData {\n        contactPerson\n        identifierType\n        identifierNumber\n        signers {\n          name\n          email\n          role\n        }\n      }\n    }\n    isGeneratingCertificate\n    lastShareCertificate {\n      id\n      name\n    }\n    shareholdings(includeLastComment: true) {\n      transactionId\n      shareholderId\n      transactionDate\n      transactionType\n      shares\n      amount\n      sharetype {\n        id\n        symbol\n      }\n      accumulatedShares\n      unpaid\n      shareSplitFactor\n      paidInTransfer\n      lastShareCertificate {\n        id\n        name\n      }\n      lastComment\n      attachedDocumentId\n      attachedDocumentName\n    }\n    noteholdings {\n      transactionId: id\n      transactionDate\n      transactionType: type\n      note {\n        type\n        principal\n        interestRate\n        discountRate\n        valuationCap\n      }\n      shareholder {\n        id\n        displayName\n      }\n    }\n    optionholdings(includeLastComment: true) {\n      transactionId: id\n      transactionDate\n      transactionType: type\n      vestingValue\n      exercisePrice\n      sharetype {\n        symbol\n      }\n      esopName\n      lastComment\n    }\n    rsuholdings(includeLastComment: true) {\n      transactionId: id\n      transactionDate\n      transactionType: type\n      vestingValue\n      sharetype {\n        symbol\n      }\n      planName\n      lastComment\n    }\n    totalPaidInIssuance\n    groupedShareholdings {\n      totalShares\n      totalInvested\n      totalUnpaid\n      totalTransferPaid\n      totalTransferReceived\n      sharetype {\n        id\n        symbol\n      }\n    }\n    groupedNoteholdings {\n      totalNotes\n      totalInvested\n      notetype\n    }\n    groupedOptionholdings {\n      granted\n      vested\n      exercised\n      lapsed\n      sharetype {\n        symbol\n      }\n      esopOffer: offer {\n        id\n        group {\n          id\n          country\n          plan {\n            name\n            id\n          }\n        }\n        status\n        softStatus\n        optionPrice\n        exercisePrice\n        hasTransactions\n        vestStartDate\n        status\n        emailsOn\n        calendar {\n          data: entries {\n            x: date\n            y: accumulated\n            vestingValue\n            lapsed\n            entryType\n            transactionId\n          }\n          vestStartDate\n        }\n        vestingEvents {\n          id\n          order\n          vestingValue\n          eventType\n          transactionSet: esoptransactionSet {\n            id\n            transactionDate\n            vestingValue\n            type\n          }\n          vestingData {\n            description\n            duration {\n              value\n              granularity\n            }\n            frequency {\n              value\n              granularity\n            }\n          }\n        }\n      }\n    }\n    groupedShareVestHoldings {\n      granted\n      vested\n      sharetype {\n        symbol\n      }\n      essOffer: offer {\n        id\n        group {\n          plan {\n            name\n            id\n          }\n        }\n        status\n        hasTransactions\n        vestStartDate\n        status\n        softStatus\n        transactionSet: esstransactionSet {\n          vestingValue\n          transactionDate\n          type\n        }\n        calendar {\n          data: entries {\n            x: date\n            y: accumulated\n            vestingValue\n            entryType\n            transactionId\n          }\n          vestStartDate\n        }\n        vestingEvents {\n          id\n          order\n          vestingValue\n          eventType\n          transactionSet: esstransactionSet {\n            id\n          }\n          vestingData {\n            description\n            duration {\n              value\n              granularity\n            }\n            frequency {\n              value\n              granularity\n            }\n          }\n        }\n      }\n    }\n    groupedFounderVestingHoldings {\n      granted\n      vested\n      sharetype {\n        symbol\n      }\n      founderVestingOffer: offer {\n        id\n        group {\n          plan {\n            name\n            id\n          }\n        }\n        status\n        hasTransactions\n        vestStartDate\n        status\n        softStatus\n        emailsOn\n        transactionSet: foundervestingtransactionSet {\n          vestingValue\n          transactionDate\n          type\n        }\n        calendar {\n          data: entries {\n            x: date\n            y: accumulated\n            vestingValue\n            entryType\n            transactionId\n          }\n          vestStartDate\n        }\n        vestingEvents {\n          id\n          order\n          vestingValue\n          eventType\n          transactionSet: foundervestingtransactionSet {\n            id\n          }\n          vestingData {\n            description\n            duration {\n              value\n              granularity\n            }\n            frequency {\n              value\n              granularity\n            }\n          }\n        }\n      }\n    }\n    groupedRsuHoldings {\n      granted\n      vested\n      exercised\n      lapsed\n      sharetype {\n        symbol\n      }\n      rsuOffer: offer {\n        id\n        group {\n          id\n          country\n          plan {\n            name\n            id\n          }\n        }\n        status\n        softStatus\n        hasTransactions\n        vestStartDate\n        status\n        emailsOn\n        calendar {\n          data: entries {\n            x: date\n            y: accumulated\n            vestingValue\n            lapsed\n            entryType\n            transactionId\n          }\n          vestStartDate\n        }\n        vestingEvents {\n          id\n          order\n          vestingValue\n          eventType\n          transactionSet: rsutransactionSet {\n            id\n            transactionDate\n            vestingValue\n            type\n          }\n          vestingData {\n            description\n            duration {\n              value\n              granularity\n            }\n            frequency {\n              value\n              granularity\n            }\n          }\n        }\n      }\n    }\n    groupedBeneficiariesShareholdings @include(if: $isTrust) {\n      beneficiary {\n        id\n        displayName\n        hasLoggedIn\n        consideredInvited\n        investorData {\n          name\n          email\n        }\n      }\n      totalShares\n      totalInvested\n      totalUnpaid\n      sharetype {\n        name\n        symbol\n      }\n    }\n    groupedShareholdingsInTrust @skip(if: $isTrust) {\n      trustee {\n        id\n        displayName\n        hasLoggedIn\n        consideredInvited\n      }\n      totalShares\n      totalInvested\n      totalUnpaid\n      sharetype {\n        name\n        symbol\n      }\n    }\n    beneficiaryShareholdings @skip(if: $isTrust) {\n      transactionId\n      shareholderId\n      shareholderName\n      transactionDate\n      transactionType\n      shares\n      amount\n      sharetype {\n        symbol\n      }\n      accumulatedShares\n      unpaid\n      shareSplitFactor\n      paidInTransfer\n      lastShareCertificate {\n        id\n        name\n      }\n      lastComment\n    }\n  }\n  shareholderDocument(organisation: $organisation, shareholder: $shareholder) {\n    id\n    name\n    extension\n  }\n  organisation(organisationId: $organisationId) {\n    lastCertificateNumber\n    totalSharesUnexercised\n    totalShares\n    shareCertificateType\n  }\n}\n    `;\n\n/**\n * __useGetShareholdersFullDataQuery__\n *\n * To run a query within a React component, call `useGetShareholdersFullDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetShareholdersFullDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetShareholdersFullDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      organisation: // value for 'organisation'\n *      shareholderId: // value for 'shareholderId'\n *      shareholder: // value for 'shareholder'\n *      isTrust: // value for 'isTrust'\n *   },\n * });\n */\nexport function useGetShareholdersFullDataQuery(baseOptions: Apollo.QueryHookOptions<GetShareholdersFullDataQuery, GetShareholdersFullDataQueryVariables> & ({ variables: GetShareholdersFullDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetShareholdersFullDataQuery, GetShareholdersFullDataQueryVariables>(GetShareholdersFullDataDocument, options);\n      }\nexport function useGetShareholdersFullDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetShareholdersFullDataQuery, GetShareholdersFullDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetShareholdersFullDataQuery, GetShareholdersFullDataQueryVariables>(GetShareholdersFullDataDocument, options);\n        }\nexport function useGetShareholdersFullDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetShareholdersFullDataQuery, GetShareholdersFullDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetShareholdersFullDataQuery, GetShareholdersFullDataQueryVariables>(GetShareholdersFullDataDocument, options);\n        }\nexport type GetShareholdersFullDataQueryHookResult = ReturnType<typeof useGetShareholdersFullDataQuery>;\nexport type GetShareholdersFullDataLazyQueryHookResult = ReturnType<typeof useGetShareholdersFullDataLazyQuery>;\nexport type GetShareholdersFullDataSuspenseQueryHookResult = ReturnType<typeof useGetShareholdersFullDataSuspenseQuery>;\nexport type GetShareholdersFullDataQueryResult = Apollo.QueryResult<GetShareholdersFullDataQuery, GetShareholdersFullDataQueryVariables>;\nexport function refetchGetShareholdersFullDataQuery(variables: GetShareholdersFullDataQueryVariables) {\n      return { query: GetShareholdersFullDataDocument, variables: variables };\n    }\nexport const GetPeopleDocument: TypedDocumentNode<GetPeopleQuery, GetPeopleQueryVariables> = gql`\n  query getPeople($organisation: OrganisationCakeType!, $page: Int!, $itemsPerPage: Int!, $filters: [ListFilterType!], $sort: [CleanString!], $search: CleanString) {\n  getPeople(\n    organisation: $organisation\n    page: $page\n    itemsPerPage: $itemsPerPage\n    filters: $filters\n    sort: $sort\n    search: $search\n  ) {\n    notSignedUpCount\n    count\n    currentPage\n    pageData {\n      id\n      displayName\n      primaryName\n      secondaryName\n      primaryEmail\n      secondaryEmail\n      primaryAddress {\n        line1\n        line2\n        line3\n        locality\n        postcode\n        country\n        administrativeArea1\n      }\n      hasLoggedIn\n      consideredInvited\n      avatar\n      shareholderType\n      identificationCode\n      messagesCount\n      sharedDocumentsCount\n      primaryPhone\n      trustName\n    }\n  }\n  orgCountriesAndStates(organisation: $organisation) {\n    countries\n    states\n  }\n}\n    `;\n\n/**\n * __useGetPeopleQuery__\n *\n * To run a query within a React component, call `useGetPeopleQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPeopleQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPeopleQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      filters: // value for 'filters'\n *      sort: // value for 'sort'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetPeopleQuery(baseOptions: Apollo.QueryHookOptions<GetPeopleQuery, GetPeopleQueryVariables> & ({ variables: GetPeopleQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPeopleQuery, GetPeopleQueryVariables>(GetPeopleDocument, options);\n      }\nexport function useGetPeopleLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPeopleQuery, GetPeopleQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPeopleQuery, GetPeopleQueryVariables>(GetPeopleDocument, options);\n        }\nexport function useGetPeopleSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPeopleQuery, GetPeopleQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPeopleQuery, GetPeopleQueryVariables>(GetPeopleDocument, options);\n        }\nexport type GetPeopleQueryHookResult = ReturnType<typeof useGetPeopleQuery>;\nexport type GetPeopleLazyQueryHookResult = ReturnType<typeof useGetPeopleLazyQuery>;\nexport type GetPeopleSuspenseQueryHookResult = ReturnType<typeof useGetPeopleSuspenseQuery>;\nexport type GetPeopleQueryResult = Apollo.QueryResult<GetPeopleQuery, GetPeopleQueryVariables>;\nexport function refetchGetPeopleQuery(variables: GetPeopleQueryVariables) {\n      return { query: GetPeopleDocument, variables: variables };\n    }\nexport const StakeholdersMergePreviewDocument: TypedDocumentNode<StakeholdersMergePreviewQuery, StakeholdersMergePreviewQueryVariables> = gql`\n  query stakeholdersMergePreview($obsoleteShareholder: ShareholderCakeType!, $prevalentShareholder: ShareholderCakeType!) {\n  stakeholdersMergePreview(\n    obsoleteShareholder: $obsoleteShareholder\n    prevalentShareholder: $prevalentShareholder\n  ) {\n    obsoleteShareholderPreview {\n      sharetypeHoldings {\n        id\n        symbol\n        name\n        shares\n      }\n      vestableHoldings {\n        planType\n        granted\n      }\n      documentCount\n      messageCount\n    }\n    prevalentShareholderPreview {\n      sharetypeHoldings {\n        id\n        symbol\n        name\n        shares\n      }\n      vestableHoldings {\n        planType\n        granted\n      }\n      documentCount\n      messageCount\n    }\n  }\n}\n    `;\n\n/**\n * __useStakeholdersMergePreviewQuery__\n *\n * To run a query within a React component, call `useStakeholdersMergePreviewQuery` and pass it any options that fit your needs.\n * When your component renders, `useStakeholdersMergePreviewQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useStakeholdersMergePreviewQuery({\n *   variables: {\n *      obsoleteShareholder: // value for 'obsoleteShareholder'\n *      prevalentShareholder: // value for 'prevalentShareholder'\n *   },\n * });\n */\nexport function useStakeholdersMergePreviewQuery(baseOptions: Apollo.QueryHookOptions<StakeholdersMergePreviewQuery, StakeholdersMergePreviewQueryVariables> & ({ variables: StakeholdersMergePreviewQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<StakeholdersMergePreviewQuery, StakeholdersMergePreviewQueryVariables>(StakeholdersMergePreviewDocument, options);\n      }\nexport function useStakeholdersMergePreviewLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<StakeholdersMergePreviewQuery, StakeholdersMergePreviewQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<StakeholdersMergePreviewQuery, StakeholdersMergePreviewQueryVariables>(StakeholdersMergePreviewDocument, options);\n        }\nexport function useStakeholdersMergePreviewSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<StakeholdersMergePreviewQuery, StakeholdersMergePreviewQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<StakeholdersMergePreviewQuery, StakeholdersMergePreviewQueryVariables>(StakeholdersMergePreviewDocument, options);\n        }\nexport type StakeholdersMergePreviewQueryHookResult = ReturnType<typeof useStakeholdersMergePreviewQuery>;\nexport type StakeholdersMergePreviewLazyQueryHookResult = ReturnType<typeof useStakeholdersMergePreviewLazyQuery>;\nexport type StakeholdersMergePreviewSuspenseQueryHookResult = ReturnType<typeof useStakeholdersMergePreviewSuspenseQuery>;\nexport type StakeholdersMergePreviewQueryResult = Apollo.QueryResult<StakeholdersMergePreviewQuery, StakeholdersMergePreviewQueryVariables>;\nexport function refetchStakeholdersMergePreviewQuery(variables: StakeholdersMergePreviewQueryVariables) {\n      return { query: StakeholdersMergePreviewDocument, variables: variables };\n    }\nexport const MergeStakeholdersDocument: TypedDocumentNode<MergeStakeholdersMutation, MergeStakeholdersMutationVariables> = gql`\n  mutation mergeStakeholders($obsoleteShareholder: ShareholderCakeType!, $prevalentShareholder: ShareholderCakeType!) {\n  mergeStakeholders(\n    obsoleteShareholder: $obsoleteShareholder\n    prevalentShareholder: $prevalentShareholder\n  )\n}\n    `;\nexport type MergeStakeholdersMutationFn = Apollo.MutationFunction<MergeStakeholdersMutation, MergeStakeholdersMutationVariables>;\n\n/**\n * __useMergeStakeholdersMutation__\n *\n * To run a mutation, you first call `useMergeStakeholdersMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useMergeStakeholdersMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [mergeStakeholdersMutation, { data, loading, error }] = useMergeStakeholdersMutation({\n *   variables: {\n *      obsoleteShareholder: // value for 'obsoleteShareholder'\n *      prevalentShareholder: // value for 'prevalentShareholder'\n *   },\n * });\n */\nexport function useMergeStakeholdersMutation(baseOptions?: Apollo.MutationHookOptions<MergeStakeholdersMutation, MergeStakeholdersMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<MergeStakeholdersMutation, MergeStakeholdersMutationVariables>(MergeStakeholdersDocument, options);\n      }\nexport type MergeStakeholdersMutationHookResult = ReturnType<typeof useMergeStakeholdersMutation>;\nexport type MergeStakeholdersMutationResult = Apollo.MutationResult<MergeStakeholdersMutation>;\nexport type MergeStakeholdersMutationOptions = Apollo.BaseMutationOptions<MergeStakeholdersMutation, MergeStakeholdersMutationVariables>;\nexport const GetEquityRaiseFormDataDocument: TypedDocumentNode<GetEquityRaiseFormDataQuery, GetEquityRaiseFormDataQueryVariables> = gql`\n  query getEquityRaiseFormData($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    sharetypeSet {\n      id\n      name\n      symbol\n    }\n    totalSharesUnexercised\n    totalShares\n  }\n}\n    `;\n\n/**\n * __useGetEquityRaiseFormDataQuery__\n *\n * To run a query within a React component, call `useGetEquityRaiseFormDataQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetEquityRaiseFormDataQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetEquityRaiseFormDataQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetEquityRaiseFormDataQuery(baseOptions: Apollo.QueryHookOptions<GetEquityRaiseFormDataQuery, GetEquityRaiseFormDataQueryVariables> & ({ variables: GetEquityRaiseFormDataQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetEquityRaiseFormDataQuery, GetEquityRaiseFormDataQueryVariables>(GetEquityRaiseFormDataDocument, options);\n      }\nexport function useGetEquityRaiseFormDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetEquityRaiseFormDataQuery, GetEquityRaiseFormDataQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetEquityRaiseFormDataQuery, GetEquityRaiseFormDataQueryVariables>(GetEquityRaiseFormDataDocument, options);\n        }\nexport function useGetEquityRaiseFormDataSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetEquityRaiseFormDataQuery, GetEquityRaiseFormDataQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetEquityRaiseFormDataQuery, GetEquityRaiseFormDataQueryVariables>(GetEquityRaiseFormDataDocument, options);\n        }\nexport type GetEquityRaiseFormDataQueryHookResult = ReturnType<typeof useGetEquityRaiseFormDataQuery>;\nexport type GetEquityRaiseFormDataLazyQueryHookResult = ReturnType<typeof useGetEquityRaiseFormDataLazyQuery>;\nexport type GetEquityRaiseFormDataSuspenseQueryHookResult = ReturnType<typeof useGetEquityRaiseFormDataSuspenseQuery>;\nexport type GetEquityRaiseFormDataQueryResult = Apollo.QueryResult<GetEquityRaiseFormDataQuery, GetEquityRaiseFormDataQueryVariables>;\nexport function refetchGetEquityRaiseFormDataQuery(variables: GetEquityRaiseFormDataQueryVariables) {\n      return { query: GetEquityRaiseFormDataDocument, variables: variables };\n    }\nexport const GetRaisesSummaryDocument: TypedDocumentNode<GetRaisesSummaryQuery, GetRaisesSummaryQueryVariables> = gql`\n  query getRaisesSummary($organisationId: OrganisationCakeType!) {\n  equityRounds(organisation: $organisationId) {\n    id\n    name\n    raiseGoalAmount\n    endDate\n    amountPaid\n    amountRaised\n  }\n  notesRounds(organisation: $organisationId) {\n    id\n    name\n    roundInvestmentGoal\n    amountPaid\n    amountRaised\n    endDate\n  }\n}\n    `;\n\n/**\n * __useGetRaisesSummaryQuery__\n *\n * To run a query within a React component, call `useGetRaisesSummaryQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetRaisesSummaryQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetRaisesSummaryQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetRaisesSummaryQuery(baseOptions: Apollo.QueryHookOptions<GetRaisesSummaryQuery, GetRaisesSummaryQueryVariables> & ({ variables: GetRaisesSummaryQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetRaisesSummaryQuery, GetRaisesSummaryQueryVariables>(GetRaisesSummaryDocument, options);\n      }\nexport function useGetRaisesSummaryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetRaisesSummaryQuery, GetRaisesSummaryQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetRaisesSummaryQuery, GetRaisesSummaryQueryVariables>(GetRaisesSummaryDocument, options);\n        }\nexport function useGetRaisesSummarySuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetRaisesSummaryQuery, GetRaisesSummaryQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetRaisesSummaryQuery, GetRaisesSummaryQueryVariables>(GetRaisesSummaryDocument, options);\n        }\nexport type GetRaisesSummaryQueryHookResult = ReturnType<typeof useGetRaisesSummaryQuery>;\nexport type GetRaisesSummaryLazyQueryHookResult = ReturnType<typeof useGetRaisesSummaryLazyQuery>;\nexport type GetRaisesSummarySuspenseQueryHookResult = ReturnType<typeof useGetRaisesSummarySuspenseQuery>;\nexport type GetRaisesSummaryQueryResult = Apollo.QueryResult<GetRaisesSummaryQuery, GetRaisesSummaryQueryVariables>;\nexport function refetchGetRaisesSummaryQuery(variables: GetRaisesSummaryQueryVariables) {\n      return { query: GetRaisesSummaryDocument, variables: variables };\n    }\nexport const GetEquityRoundDocument: TypedDocumentNode<GetEquityRoundQuery, GetEquityRoundQueryVariables> = gql`\n  query getEquityRound($organisationId: UUID!, $organisation: OrganisationCakeType!, $roundId: UUID!) {\n  equityRounds(organisation: $organisation, filterRound: $roundId) {\n    id\n    name\n    raiseGoalAmount\n    created\n    valuation\n    existingShares\n    minInvestAmount\n    maxInvestAmount\n    endDate\n    amountPaid\n    amountRaised\n    companyOffered\n    payment {\n      ... on AuPaymentDetailsType {\n        accountName\n        accountNumber\n        bsb\n        reference\n        isTrustAccount\n      }\n      ... on SgPaymentDetailsType {\n        accountName\n        accountNumber\n        swiftCode\n        bankCode\n        branchCode\n      }\n      ... on FallbackPaymentDetailsType {\n        details\n      }\n    }\n    contractTemplate {\n      id\n      name\n      status\n      contractType\n    }\n    shareType {\n      id\n      name\n    }\n    documents {\n      id\n      created\n      name\n      file\n      extension\n    }\n  }\n  officeholders(organisationId: $organisationId, filterSigners: true) {\n    id\n    name\n    email\n    avatar\n    roles {\n      role\n      name\n    }\n    signer\n  }\n}\n    `;\n\n/**\n * __useGetEquityRoundQuery__\n *\n * To run a query within a React component, call `useGetEquityRoundQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetEquityRoundQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetEquityRoundQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      organisation: // value for 'organisation'\n *      roundId: // value for 'roundId'\n *   },\n * });\n */\nexport function useGetEquityRoundQuery(baseOptions: Apollo.QueryHookOptions<GetEquityRoundQuery, GetEquityRoundQueryVariables> & ({ variables: GetEquityRoundQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetEquityRoundQuery, GetEquityRoundQueryVariables>(GetEquityRoundDocument, options);\n      }\nexport function useGetEquityRoundLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetEquityRoundQuery, GetEquityRoundQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetEquityRoundQuery, GetEquityRoundQueryVariables>(GetEquityRoundDocument, options);\n        }\nexport function useGetEquityRoundSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetEquityRoundQuery, GetEquityRoundQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetEquityRoundQuery, GetEquityRoundQueryVariables>(GetEquityRoundDocument, options);\n        }\nexport type GetEquityRoundQueryHookResult = ReturnType<typeof useGetEquityRoundQuery>;\nexport type GetEquityRoundLazyQueryHookResult = ReturnType<typeof useGetEquityRoundLazyQuery>;\nexport type GetEquityRoundSuspenseQueryHookResult = ReturnType<typeof useGetEquityRoundSuspenseQuery>;\nexport type GetEquityRoundQueryResult = Apollo.QueryResult<GetEquityRoundQuery, GetEquityRoundQueryVariables>;\nexport function refetchGetEquityRoundQuery(variables: GetEquityRoundQueryVariables) {\n      return { query: GetEquityRoundDocument, variables: variables };\n    }\nexport const RaiseOffersDocument: TypedDocumentNode<RaiseOffersQuery, RaiseOffersQueryVariables> = gql`\n  query raiseOffers($round: OrganisationRaiseCakeType!, $organisationId: UUID!, $page: Int, $itemsPerPage: Int, $offer: UUID) {\n  raiseOffers(\n    round: $round\n    page: $page\n    itemsPerPage: $itemsPerPage\n    filterOffer: $offer\n  ) {\n    count\n    currentPage\n    pageData {\n      id\n      modified\n      amount\n      owing\n      reminderSentDate\n      status\n      expectedShares\n      requireWitness\n      shareholder {\n        id\n        displayName\n        secondaryName\n        avatar\n        inviteLink\n        computedType\n        investorData {\n          name\n          email\n          jointIndex\n          companyData {\n            signers {\n              name\n              email\n            }\n          }\n        }\n      }\n      certificate {\n        id\n        name\n        contractType\n      }\n      contract {\n        id\n        name\n        contractType\n        signatures {\n          name\n          email\n          status\n          extra\n        }\n      }\n      organisationRaise {\n        id\n      }\n    }\n  }\n  organisation(organisationId: $organisationId) {\n    lastCertificateNumber\n  }\n}\n    `;\n\n/**\n * __useRaiseOffersQuery__\n *\n * To run a query within a React component, call `useRaiseOffersQuery` and pass it any options that fit your needs.\n * When your component renders, `useRaiseOffersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useRaiseOffersQuery({\n *   variables: {\n *      round: // value for 'round'\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      offer: // value for 'offer'\n *   },\n * });\n */\nexport function useRaiseOffersQuery(baseOptions: Apollo.QueryHookOptions<RaiseOffersQuery, RaiseOffersQueryVariables> & ({ variables: RaiseOffersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<RaiseOffersQuery, RaiseOffersQueryVariables>(RaiseOffersDocument, options);\n      }\nexport function useRaiseOffersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<RaiseOffersQuery, RaiseOffersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<RaiseOffersQuery, RaiseOffersQueryVariables>(RaiseOffersDocument, options);\n        }\nexport function useRaiseOffersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<RaiseOffersQuery, RaiseOffersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<RaiseOffersQuery, RaiseOffersQueryVariables>(RaiseOffersDocument, options);\n        }\nexport type RaiseOffersQueryHookResult = ReturnType<typeof useRaiseOffersQuery>;\nexport type RaiseOffersLazyQueryHookResult = ReturnType<typeof useRaiseOffersLazyQuery>;\nexport type RaiseOffersSuspenseQueryHookResult = ReturnType<typeof useRaiseOffersSuspenseQuery>;\nexport type RaiseOffersQueryResult = Apollo.QueryResult<RaiseOffersQuery, RaiseOffersQueryVariables>;\nexport function refetchRaiseOffersQuery(variables: RaiseOffersQueryVariables) {\n      return { query: RaiseOffersDocument, variables: variables };\n    }\nexport const CreateEquityRoundDocument: TypedDocumentNode<CreateEquityRoundMutation, CreateEquityRoundMutationVariables> = gql`\n  mutation createEquityRound($organisation: OrganisationCakeType!, $name: CleanString!, $raiseGoalAmount: CakeDecimal!, $existingShares: PositiveIntegerOrZero!, $valuation: ValuationCakeType!, $shareType: SharetypeCakeType!, $endDate: Date!, $payment: JSONString) {\n  createEquityRound(\n    organisation: $organisation\n    name: $name\n    raiseGoalAmount: $raiseGoalAmount\n    existingShares: $existingShares\n    valuation: $valuation\n    shareType: $shareType\n    endDate: $endDate\n    payment: $payment\n  ) {\n    organisationRaise {\n      id\n    }\n  }\n}\n    `;\nexport type CreateEquityRoundMutationFn = Apollo.MutationFunction<CreateEquityRoundMutation, CreateEquityRoundMutationVariables>;\n\n/**\n * __useCreateEquityRoundMutation__\n *\n * To run a mutation, you first call `useCreateEquityRoundMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateEquityRoundMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createEquityRoundMutation, { data, loading, error }] = useCreateEquityRoundMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      name: // value for 'name'\n *      raiseGoalAmount: // value for 'raiseGoalAmount'\n *      existingShares: // value for 'existingShares'\n *      valuation: // value for 'valuation'\n *      shareType: // value for 'shareType'\n *      endDate: // value for 'endDate'\n *      payment: // value for 'payment'\n *   },\n * });\n */\nexport function useCreateEquityRoundMutation(baseOptions?: Apollo.MutationHookOptions<CreateEquityRoundMutation, CreateEquityRoundMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateEquityRoundMutation, CreateEquityRoundMutationVariables>(CreateEquityRoundDocument, options);\n      }\nexport type CreateEquityRoundMutationHookResult = ReturnType<typeof useCreateEquityRoundMutation>;\nexport type CreateEquityRoundMutationResult = Apollo.MutationResult<CreateEquityRoundMutation>;\nexport type CreateEquityRoundMutationOptions = Apollo.BaseMutationOptions<CreateEquityRoundMutation, CreateEquityRoundMutationVariables>;\nexport const EditEquityRoundDocument: TypedDocumentNode<EditEquityRoundMutation, EditEquityRoundMutationVariables> = gql`\n  mutation editEquityRound($round: OrganisationRaiseCakeType!, $name: CleanString, $endDate: Date, $raiseGoalAmount: CakeDecimal, $existingShares: PositiveIntegerOrZero, $shareType: SharetypeCakeType) {\n  editEquityRound(\n    round: $round\n    name: $name\n    endDate: $endDate\n    raiseGoalAmount: $raiseGoalAmount\n    existingShares: $existingShares\n    shareType: $shareType\n  ) {\n    ok\n  }\n}\n    `;\nexport type EditEquityRoundMutationFn = Apollo.MutationFunction<EditEquityRoundMutation, EditEquityRoundMutationVariables>;\n\n/**\n * __useEditEquityRoundMutation__\n *\n * To run a mutation, you first call `useEditEquityRoundMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditEquityRoundMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editEquityRoundMutation, { data, loading, error }] = useEditEquityRoundMutation({\n *   variables: {\n *      round: // value for 'round'\n *      name: // value for 'name'\n *      endDate: // value for 'endDate'\n *      raiseGoalAmount: // value for 'raiseGoalAmount'\n *      existingShares: // value for 'existingShares'\n *      shareType: // value for 'shareType'\n *   },\n * });\n */\nexport function useEditEquityRoundMutation(baseOptions?: Apollo.MutationHookOptions<EditEquityRoundMutation, EditEquityRoundMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditEquityRoundMutation, EditEquityRoundMutationVariables>(EditEquityRoundDocument, options);\n      }\nexport type EditEquityRoundMutationHookResult = ReturnType<typeof useEditEquityRoundMutation>;\nexport type EditEquityRoundMutationResult = Apollo.MutationResult<EditEquityRoundMutation>;\nexport type EditEquityRoundMutationOptions = Apollo.BaseMutationOptions<EditEquityRoundMutation, EditEquityRoundMutationVariables>;\nexport const UpdateEquityRoundBankDetailsAuDocument: TypedDocumentNode<UpdateEquityRoundBankDetailsAuMutation, UpdateEquityRoundBankDetailsAuMutationVariables> = gql`\n  mutation updateEquityRoundBankDetailsAu($round: OrganisationRaiseCakeType!, $accountName: String, $paymentAccount: String, $paymentBsb: String, $paymentReference: String, $isTrustAccount: Boolean) {\n  updateEquityRoundBankDetailsAu(\n    round: $round\n    accountName: $accountName\n    paymentAccount: $paymentAccount\n    paymentBsb: $paymentBsb\n    paymentReference: $paymentReference\n    isTrustAccount: $isTrustAccount\n  ) {\n    ok\n  }\n}\n    `;\nexport type UpdateEquityRoundBankDetailsAuMutationFn = Apollo.MutationFunction<UpdateEquityRoundBankDetailsAuMutation, UpdateEquityRoundBankDetailsAuMutationVariables>;\n\n/**\n * __useUpdateEquityRoundBankDetailsAuMutation__\n *\n * To run a mutation, you first call `useUpdateEquityRoundBankDetailsAuMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateEquityRoundBankDetailsAuMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateEquityRoundBankDetailsAuMutation, { data, loading, error }] = useUpdateEquityRoundBankDetailsAuMutation({\n *   variables: {\n *      round: // value for 'round'\n *      accountName: // value for 'accountName'\n *      paymentAccount: // value for 'paymentAccount'\n *      paymentBsb: // value for 'paymentBsb'\n *      paymentReference: // value for 'paymentReference'\n *      isTrustAccount: // value for 'isTrustAccount'\n *   },\n * });\n */\nexport function useUpdateEquityRoundBankDetailsAuMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEquityRoundBankDetailsAuMutation, UpdateEquityRoundBankDetailsAuMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateEquityRoundBankDetailsAuMutation, UpdateEquityRoundBankDetailsAuMutationVariables>(UpdateEquityRoundBankDetailsAuDocument, options);\n      }\nexport type UpdateEquityRoundBankDetailsAuMutationHookResult = ReturnType<typeof useUpdateEquityRoundBankDetailsAuMutation>;\nexport type UpdateEquityRoundBankDetailsAuMutationResult = Apollo.MutationResult<UpdateEquityRoundBankDetailsAuMutation>;\nexport type UpdateEquityRoundBankDetailsAuMutationOptions = Apollo.BaseMutationOptions<UpdateEquityRoundBankDetailsAuMutation, UpdateEquityRoundBankDetailsAuMutationVariables>;\nexport const UpdateEquityRoundBankDetailsSgDocument: TypedDocumentNode<UpdateEquityRoundBankDetailsSgMutation, UpdateEquityRoundBankDetailsSgMutationVariables> = gql`\n  mutation updateEquityRoundBankDetailsSg($round: OrganisationRaiseCakeType!, $accountName: String, $accountNumber: String, $swiftCode: String, $bankCode: String, $branchCode: String) {\n  updateEquityRoundBankDetailsSg(\n    round: $round\n    accountName: $accountName\n    accountNumber: $accountNumber\n    swiftCode: $swiftCode\n    bankCode: $bankCode\n    branchCode: $branchCode\n  ) {\n    ok\n  }\n}\n    `;\nexport type UpdateEquityRoundBankDetailsSgMutationFn = Apollo.MutationFunction<UpdateEquityRoundBankDetailsSgMutation, UpdateEquityRoundBankDetailsSgMutationVariables>;\n\n/**\n * __useUpdateEquityRoundBankDetailsSgMutation__\n *\n * To run a mutation, you first call `useUpdateEquityRoundBankDetailsSgMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateEquityRoundBankDetailsSgMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateEquityRoundBankDetailsSgMutation, { data, loading, error }] = useUpdateEquityRoundBankDetailsSgMutation({\n *   variables: {\n *      round: // value for 'round'\n *      accountName: // value for 'accountName'\n *      accountNumber: // value for 'accountNumber'\n *      swiftCode: // value for 'swiftCode'\n *      bankCode: // value for 'bankCode'\n *      branchCode: // value for 'branchCode'\n *   },\n * });\n */\nexport function useUpdateEquityRoundBankDetailsSgMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEquityRoundBankDetailsSgMutation, UpdateEquityRoundBankDetailsSgMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateEquityRoundBankDetailsSgMutation, UpdateEquityRoundBankDetailsSgMutationVariables>(UpdateEquityRoundBankDetailsSgDocument, options);\n      }\nexport type UpdateEquityRoundBankDetailsSgMutationHookResult = ReturnType<typeof useUpdateEquityRoundBankDetailsSgMutation>;\nexport type UpdateEquityRoundBankDetailsSgMutationResult = Apollo.MutationResult<UpdateEquityRoundBankDetailsSgMutation>;\nexport type UpdateEquityRoundBankDetailsSgMutationOptions = Apollo.BaseMutationOptions<UpdateEquityRoundBankDetailsSgMutation, UpdateEquityRoundBankDetailsSgMutationVariables>;\nexport const UpdateEquityRoundBankDetailsFallbackDocument: TypedDocumentNode<UpdateEquityRoundBankDetailsFallbackMutation, UpdateEquityRoundBankDetailsFallbackMutationVariables> = gql`\n  mutation updateEquityRoundBankDetailsFallback($round: OrganisationRaiseCakeType!, $details: String) {\n  updateEquityRoundBankDetailsFallback(round: $round, details: $details) {\n    ok\n  }\n}\n    `;\nexport type UpdateEquityRoundBankDetailsFallbackMutationFn = Apollo.MutationFunction<UpdateEquityRoundBankDetailsFallbackMutation, UpdateEquityRoundBankDetailsFallbackMutationVariables>;\n\n/**\n * __useUpdateEquityRoundBankDetailsFallbackMutation__\n *\n * To run a mutation, you first call `useUpdateEquityRoundBankDetailsFallbackMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateEquityRoundBankDetailsFallbackMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateEquityRoundBankDetailsFallbackMutation, { data, loading, error }] = useUpdateEquityRoundBankDetailsFallbackMutation({\n *   variables: {\n *      round: // value for 'round'\n *      details: // value for 'details'\n *   },\n * });\n */\nexport function useUpdateEquityRoundBankDetailsFallbackMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEquityRoundBankDetailsFallbackMutation, UpdateEquityRoundBankDetailsFallbackMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateEquityRoundBankDetailsFallbackMutation, UpdateEquityRoundBankDetailsFallbackMutationVariables>(UpdateEquityRoundBankDetailsFallbackDocument, options);\n      }\nexport type UpdateEquityRoundBankDetailsFallbackMutationHookResult = ReturnType<typeof useUpdateEquityRoundBankDetailsFallbackMutation>;\nexport type UpdateEquityRoundBankDetailsFallbackMutationResult = Apollo.MutationResult<UpdateEquityRoundBankDetailsFallbackMutation>;\nexport type UpdateEquityRoundBankDetailsFallbackMutationOptions = Apollo.BaseMutationOptions<UpdateEquityRoundBankDetailsFallbackMutation, UpdateEquityRoundBankDetailsFallbackMutationVariables>;\nexport const DeleteEquityRoundDocument: TypedDocumentNode<DeleteEquityRoundMutation, DeleteEquityRoundMutationVariables> = gql`\n  mutation deleteEquityRound($round: OrganisationRaiseCakeType!) {\n  deleteEquityRound(round: $round) {\n    ok\n  }\n}\n    `;\nexport type DeleteEquityRoundMutationFn = Apollo.MutationFunction<DeleteEquityRoundMutation, DeleteEquityRoundMutationVariables>;\n\n/**\n * __useDeleteEquityRoundMutation__\n *\n * To run a mutation, you first call `useDeleteEquityRoundMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteEquityRoundMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteEquityRoundMutation, { data, loading, error }] = useDeleteEquityRoundMutation({\n *   variables: {\n *      round: // value for 'round'\n *   },\n * });\n */\nexport function useDeleteEquityRoundMutation(baseOptions?: Apollo.MutationHookOptions<DeleteEquityRoundMutation, DeleteEquityRoundMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteEquityRoundMutation, DeleteEquityRoundMutationVariables>(DeleteEquityRoundDocument, options);\n      }\nexport type DeleteEquityRoundMutationHookResult = ReturnType<typeof useDeleteEquityRoundMutation>;\nexport type DeleteEquityRoundMutationResult = Apollo.MutationResult<DeleteEquityRoundMutation>;\nexport type DeleteEquityRoundMutationOptions = Apollo.BaseMutationOptions<DeleteEquityRoundMutation, DeleteEquityRoundMutationVariables>;\nexport const AddEquityRoundOfferDocument: TypedDocumentNode<AddEquityRoundOfferMutation, AddEquityRoundOfferMutationVariables> = gql`\n  mutation addEquityRoundOffer($round: OrganisationRaiseCakeType!, $shareholder: ShareholderCakeType!, $amount: CakeDecimal!) {\n  addEquityRoundOffer(round: $round, shareholder: $shareholder, amount: $amount) {\n    organisationRaiseOffer {\n      id\n    }\n  }\n}\n    `;\nexport type AddEquityRoundOfferMutationFn = Apollo.MutationFunction<AddEquityRoundOfferMutation, AddEquityRoundOfferMutationVariables>;\n\n/**\n * __useAddEquityRoundOfferMutation__\n *\n * To run a mutation, you first call `useAddEquityRoundOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddEquityRoundOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addEquityRoundOfferMutation, { data, loading, error }] = useAddEquityRoundOfferMutation({\n *   variables: {\n *      round: // value for 'round'\n *      shareholder: // value for 'shareholder'\n *      amount: // value for 'amount'\n *   },\n * });\n */\nexport function useAddEquityRoundOfferMutation(baseOptions?: Apollo.MutationHookOptions<AddEquityRoundOfferMutation, AddEquityRoundOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddEquityRoundOfferMutation, AddEquityRoundOfferMutationVariables>(AddEquityRoundOfferDocument, options);\n      }\nexport type AddEquityRoundOfferMutationHookResult = ReturnType<typeof useAddEquityRoundOfferMutation>;\nexport type AddEquityRoundOfferMutationResult = Apollo.MutationResult<AddEquityRoundOfferMutation>;\nexport type AddEquityRoundOfferMutationOptions = Apollo.BaseMutationOptions<AddEquityRoundOfferMutation, AddEquityRoundOfferMutationVariables>;\nexport const DeleteEquityRoundOfferDocument: TypedDocumentNode<DeleteEquityRoundOfferMutation, DeleteEquityRoundOfferMutationVariables> = gql`\n  mutation deleteEquityRoundOffer($offer: OrganisationRaiseOfferCakeType!) {\n  deleteEquityRoundOffer(offer: $offer) {\n    ok\n  }\n}\n    `;\nexport type DeleteEquityRoundOfferMutationFn = Apollo.MutationFunction<DeleteEquityRoundOfferMutation, DeleteEquityRoundOfferMutationVariables>;\n\n/**\n * __useDeleteEquityRoundOfferMutation__\n *\n * To run a mutation, you first call `useDeleteEquityRoundOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteEquityRoundOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteEquityRoundOfferMutation, { data, loading, error }] = useDeleteEquityRoundOfferMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *   },\n * });\n */\nexport function useDeleteEquityRoundOfferMutation(baseOptions?: Apollo.MutationHookOptions<DeleteEquityRoundOfferMutation, DeleteEquityRoundOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteEquityRoundOfferMutation, DeleteEquityRoundOfferMutationVariables>(DeleteEquityRoundOfferDocument, options);\n      }\nexport type DeleteEquityRoundOfferMutationHookResult = ReturnType<typeof useDeleteEquityRoundOfferMutation>;\nexport type DeleteEquityRoundOfferMutationResult = Apollo.MutationResult<DeleteEquityRoundOfferMutation>;\nexport type DeleteEquityRoundOfferMutationOptions = Apollo.BaseMutationOptions<DeleteEquityRoundOfferMutation, DeleteEquityRoundOfferMutationVariables>;\nexport const UpdateEquityOfferPaymentStatusDocument: TypedDocumentNode<UpdateEquityOfferPaymentStatusMutation, UpdateEquityOfferPaymentStatusMutationVariables> = gql`\n  mutation updateEquityOfferPaymentStatus($offer: OrganisationRaiseOfferCakeType!, $paid: CakeDecimal!) {\n  updateEquityOfferPaymentStatus(offer: $offer, paid: $paid) {\n    ok\n  }\n}\n    `;\nexport type UpdateEquityOfferPaymentStatusMutationFn = Apollo.MutationFunction<UpdateEquityOfferPaymentStatusMutation, UpdateEquityOfferPaymentStatusMutationVariables>;\n\n/**\n * __useUpdateEquityOfferPaymentStatusMutation__\n *\n * To run a mutation, you first call `useUpdateEquityOfferPaymentStatusMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateEquityOfferPaymentStatusMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateEquityOfferPaymentStatusMutation, { data, loading, error }] = useUpdateEquityOfferPaymentStatusMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      paid: // value for 'paid'\n *   },\n * });\n */\nexport function useUpdateEquityOfferPaymentStatusMutation(baseOptions?: Apollo.MutationHookOptions<UpdateEquityOfferPaymentStatusMutation, UpdateEquityOfferPaymentStatusMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateEquityOfferPaymentStatusMutation, UpdateEquityOfferPaymentStatusMutationVariables>(UpdateEquityOfferPaymentStatusDocument, options);\n      }\nexport type UpdateEquityOfferPaymentStatusMutationHookResult = ReturnType<typeof useUpdateEquityOfferPaymentStatusMutation>;\nexport type UpdateEquityOfferPaymentStatusMutationResult = Apollo.MutationResult<UpdateEquityOfferPaymentStatusMutation>;\nexport type UpdateEquityOfferPaymentStatusMutationOptions = Apollo.BaseMutationOptions<UpdateEquityOfferPaymentStatusMutation, UpdateEquityOfferPaymentStatusMutationVariables>;\nexport const InviteEquityOfferDocument: TypedDocumentNode<InviteEquityOfferMutation, InviteEquityOfferMutationVariables> = gql`\n  mutation inviteEquityOffer($offer: OrganisationRaiseOfferCakeType!, $sendInvitationEmail: Boolean!) {\n  inviteEquityOffer(offer: $offer, sendInvitationEmail: $sendInvitationEmail) {\n    ok\n  }\n}\n    `;\nexport type InviteEquityOfferMutationFn = Apollo.MutationFunction<InviteEquityOfferMutation, InviteEquityOfferMutationVariables>;\n\n/**\n * __useInviteEquityOfferMutation__\n *\n * To run a mutation, you first call `useInviteEquityOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useInviteEquityOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [inviteEquityOfferMutation, { data, loading, error }] = useInviteEquityOfferMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      sendInvitationEmail: // value for 'sendInvitationEmail'\n *   },\n * });\n */\nexport function useInviteEquityOfferMutation(baseOptions?: Apollo.MutationHookOptions<InviteEquityOfferMutation, InviteEquityOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<InviteEquityOfferMutation, InviteEquityOfferMutationVariables>(InviteEquityOfferDocument, options);\n      }\nexport type InviteEquityOfferMutationHookResult = ReturnType<typeof useInviteEquityOfferMutation>;\nexport type InviteEquityOfferMutationResult = Apollo.MutationResult<InviteEquityOfferMutation>;\nexport type InviteEquityOfferMutationOptions = Apollo.BaseMutationOptions<InviteEquityOfferMutation, InviteEquityOfferMutationVariables>;\nexport const SettleEquityOfferOfflineDocument: TypedDocumentNode<SettleEquityOfferOfflineMutation, SettleEquityOfferOfflineMutationVariables> = gql`\n  mutation settleEquityOfferOffline($offer: OrganisationRaiseOfferCakeType!, $amount: CakeDecimal!, $contract: DocumentCakeType) {\n  settleEquityOfferOffline(offer: $offer, amount: $amount, contract: $contract) {\n    ok\n  }\n}\n    `;\nexport type SettleEquityOfferOfflineMutationFn = Apollo.MutationFunction<SettleEquityOfferOfflineMutation, SettleEquityOfferOfflineMutationVariables>;\n\n/**\n * __useSettleEquityOfferOfflineMutation__\n *\n * To run a mutation, you first call `useSettleEquityOfferOfflineMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSettleEquityOfferOfflineMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [settleEquityOfferOfflineMutation, { data, loading, error }] = useSettleEquityOfferOfflineMutation({\n *   variables: {\n *      offer: // value for 'offer'\n *      amount: // value for 'amount'\n *      contract: // value for 'contract'\n *   },\n * });\n */\nexport function useSettleEquityOfferOfflineMutation(baseOptions?: Apollo.MutationHookOptions<SettleEquityOfferOfflineMutation, SettleEquityOfferOfflineMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SettleEquityOfferOfflineMutation, SettleEquityOfferOfflineMutationVariables>(SettleEquityOfferOfflineDocument, options);\n      }\nexport type SettleEquityOfferOfflineMutationHookResult = ReturnType<typeof useSettleEquityOfferOfflineMutation>;\nexport type SettleEquityOfferOfflineMutationResult = Apollo.MutationResult<SettleEquityOfferOfflineMutation>;\nexport type SettleEquityOfferOfflineMutationOptions = Apollo.BaseMutationOptions<SettleEquityOfferOfflineMutation, SettleEquityOfferOfflineMutationVariables>;\nexport const SignSubscriptionAgreementOfficeholderDocument: TypedDocumentNode<SignSubscriptionAgreementOfficeholderMutation, SignSubscriptionAgreementOfficeholderMutationVariables> = gql`\n  mutation signSubscriptionAgreementOfficeholder($raiseOfferId: UUID!) {\n  signSubscriptionAgreementOfficeholder(raiseOfferId: $raiseOfferId) {\n    urlList\n    signatureRequestId\n    expectedCallbackUrl\n  }\n}\n    `;\nexport type SignSubscriptionAgreementOfficeholderMutationFn = Apollo.MutationFunction<SignSubscriptionAgreementOfficeholderMutation, SignSubscriptionAgreementOfficeholderMutationVariables>;\n\n/**\n * __useSignSubscriptionAgreementOfficeholderMutation__\n *\n * To run a mutation, you first call `useSignSubscriptionAgreementOfficeholderMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSignSubscriptionAgreementOfficeholderMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [signSubscriptionAgreementOfficeholderMutation, { data, loading, error }] = useSignSubscriptionAgreementOfficeholderMutation({\n *   variables: {\n *      raiseOfferId: // value for 'raiseOfferId'\n *   },\n * });\n */\nexport function useSignSubscriptionAgreementOfficeholderMutation(baseOptions?: Apollo.MutationHookOptions<SignSubscriptionAgreementOfficeholderMutation, SignSubscriptionAgreementOfficeholderMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SignSubscriptionAgreementOfficeholderMutation, SignSubscriptionAgreementOfficeholderMutationVariables>(SignSubscriptionAgreementOfficeholderDocument, options);\n      }\nexport type SignSubscriptionAgreementOfficeholderMutationHookResult = ReturnType<typeof useSignSubscriptionAgreementOfficeholderMutation>;\nexport type SignSubscriptionAgreementOfficeholderMutationResult = Apollo.MutationResult<SignSubscriptionAgreementOfficeholderMutation>;\nexport type SignSubscriptionAgreementOfficeholderMutationOptions = Apollo.BaseMutationOptions<SignSubscriptionAgreementOfficeholderMutation, SignSubscriptionAgreementOfficeholderMutationVariables>;\nexport const GetTeamDataToRequestExerciseDocument: TypedDocumentNode<GetTeamDataToRequestExerciseQuery, GetTeamDataToRequestExerciseQueryVariables> = gql`\n  query getTeamDataToRequestExercise($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    usersWithAggregatedRoles {\n      user {\n        id\n        isLoggedInUser\n        email\n        name\n        picture\n      }\n      role\n      position\n    }\n    license {\n      billingEmail\n      billingMobile\n    }\n  }\n}\n    `;\n\n/**\n * __useGetTeamDataToRequestExerciseQuery__\n *\n * To run a query within a React component, call `useGetTeamDataToRequestExerciseQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetTeamDataToRequestExerciseQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetTeamDataToRequestExerciseQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetTeamDataToRequestExerciseQuery(baseOptions: Apollo.QueryHookOptions<GetTeamDataToRequestExerciseQuery, GetTeamDataToRequestExerciseQueryVariables> & ({ variables: GetTeamDataToRequestExerciseQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetTeamDataToRequestExerciseQuery, GetTeamDataToRequestExerciseQueryVariables>(GetTeamDataToRequestExerciseDocument, options);\n      }\nexport function useGetTeamDataToRequestExerciseLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetTeamDataToRequestExerciseQuery, GetTeamDataToRequestExerciseQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetTeamDataToRequestExerciseQuery, GetTeamDataToRequestExerciseQueryVariables>(GetTeamDataToRequestExerciseDocument, options);\n        }\nexport function useGetTeamDataToRequestExerciseSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetTeamDataToRequestExerciseQuery, GetTeamDataToRequestExerciseQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetTeamDataToRequestExerciseQuery, GetTeamDataToRequestExerciseQueryVariables>(GetTeamDataToRequestExerciseDocument, options);\n        }\nexport type GetTeamDataToRequestExerciseQueryHookResult = ReturnType<typeof useGetTeamDataToRequestExerciseQuery>;\nexport type GetTeamDataToRequestExerciseLazyQueryHookResult = ReturnType<typeof useGetTeamDataToRequestExerciseLazyQuery>;\nexport type GetTeamDataToRequestExerciseSuspenseQueryHookResult = ReturnType<typeof useGetTeamDataToRequestExerciseSuspenseQuery>;\nexport type GetTeamDataToRequestExerciseQueryResult = Apollo.QueryResult<GetTeamDataToRequestExerciseQuery, GetTeamDataToRequestExerciseQueryVariables>;\nexport function refetchGetTeamDataToRequestExerciseQuery(variables: GetTeamDataToRequestExerciseQueryVariables) {\n      return { query: GetTeamDataToRequestExerciseDocument, variables: variables };\n    }\nexport const SetupExerciseRequestSettingsDocument: TypedDocumentNode<SetupExerciseRequestSettingsMutation, SetupExerciseRequestSettingsMutationVariables> = gql`\n  mutation setupExerciseRequestSettings($organisation: OrganisationCakeType!, $approvers: [UserCakeType!]!, $paymentDetails: ExerciseRequestPaymentDetailsInputType!) {\n  setupExerciseRequestSettings(\n    organisation: $organisation\n    approvers: $approvers\n    paymentDetails: $paymentDetails\n  )\n}\n    `;\nexport type SetupExerciseRequestSettingsMutationFn = Apollo.MutationFunction<SetupExerciseRequestSettingsMutation, SetupExerciseRequestSettingsMutationVariables>;\n\n/**\n * __useSetupExerciseRequestSettingsMutation__\n *\n * To run a mutation, you first call `useSetupExerciseRequestSettingsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSetupExerciseRequestSettingsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [setupExerciseRequestSettingsMutation, { data, loading, error }] = useSetupExerciseRequestSettingsMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      approvers: // value for 'approvers'\n *      paymentDetails: // value for 'paymentDetails'\n *   },\n * });\n */\nexport function useSetupExerciseRequestSettingsMutation(baseOptions?: Apollo.MutationHookOptions<SetupExerciseRequestSettingsMutation, SetupExerciseRequestSettingsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SetupExerciseRequestSettingsMutation, SetupExerciseRequestSettingsMutationVariables>(SetupExerciseRequestSettingsDocument, options);\n      }\nexport type SetupExerciseRequestSettingsMutationHookResult = ReturnType<typeof useSetupExerciseRequestSettingsMutation>;\nexport type SetupExerciseRequestSettingsMutationResult = Apollo.MutationResult<SetupExerciseRequestSettingsMutation>;\nexport type SetupExerciseRequestSettingsMutationOptions = Apollo.BaseMutationOptions<SetupExerciseRequestSettingsMutation, SetupExerciseRequestSettingsMutationVariables>;\nexport const EditExerciseRequestSettingsDocument: TypedDocumentNode<EditExerciseRequestSettingsMutation, EditExerciseRequestSettingsMutationVariables> = gql`\n  mutation editExerciseRequestSettings($exerciseRequestSettingsId: OptionExerciseRequestSettingsCakeType!, $canRequestExercise: Boolean, $approvers: [UserCakeType!], $paymentDetails: ExerciseRequestPaymentDetailsInputType) {\n  editExerciseRequestSettings(\n    exerciseRequestSettings: $exerciseRequestSettingsId\n    canRequestExercise: $canRequestExercise\n    approvers: $approvers\n    paymentDetails: $paymentDetails\n  )\n}\n    `;\nexport type EditExerciseRequestSettingsMutationFn = Apollo.MutationFunction<EditExerciseRequestSettingsMutation, EditExerciseRequestSettingsMutationVariables>;\n\n/**\n * __useEditExerciseRequestSettingsMutation__\n *\n * To run a mutation, you first call `useEditExerciseRequestSettingsMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditExerciseRequestSettingsMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editExerciseRequestSettingsMutation, { data, loading, error }] = useEditExerciseRequestSettingsMutation({\n *   variables: {\n *      exerciseRequestSettingsId: // value for 'exerciseRequestSettingsId'\n *      canRequestExercise: // value for 'canRequestExercise'\n *      approvers: // value for 'approvers'\n *      paymentDetails: // value for 'paymentDetails'\n *   },\n * });\n */\nexport function useEditExerciseRequestSettingsMutation(baseOptions?: Apollo.MutationHookOptions<EditExerciseRequestSettingsMutation, EditExerciseRequestSettingsMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditExerciseRequestSettingsMutation, EditExerciseRequestSettingsMutationVariables>(EditExerciseRequestSettingsDocument, options);\n      }\nexport type EditExerciseRequestSettingsMutationHookResult = ReturnType<typeof useEditExerciseRequestSettingsMutation>;\nexport type EditExerciseRequestSettingsMutationResult = Apollo.MutationResult<EditExerciseRequestSettingsMutation>;\nexport type EditExerciseRequestSettingsMutationOptions = Apollo.BaseMutationOptions<EditExerciseRequestSettingsMutation, EditExerciseRequestSettingsMutationVariables>;\nexport const ExerciseRequestSettingsDocument: TypedDocumentNode<ExerciseRequestSettingsQuery, ExerciseRequestSettingsQueryVariables> = gql`\n  query exerciseRequestSettings($organisationId: OrganisationCakeType!) {\n  exerciseRequestSettings(organisation: $organisationId) {\n    id\n    canRequestExercise\n    approvers {\n      id\n      name\n      email\n      picture\n    }\n    paymentDetails {\n      accountName\n      accountNumber\n      routingNumber\n      additionalInstructions\n    }\n    exerciseNoticeTemplate {\n      id\n      name\n    }\n  }\n}\n    `;\n\n/**\n * __useExerciseRequestSettingsQuery__\n *\n * To run a query within a React component, call `useExerciseRequestSettingsQuery` and pass it any options that fit your needs.\n * When your component renders, `useExerciseRequestSettingsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useExerciseRequestSettingsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useExerciseRequestSettingsQuery(baseOptions: Apollo.QueryHookOptions<ExerciseRequestSettingsQuery, ExerciseRequestSettingsQueryVariables> & ({ variables: ExerciseRequestSettingsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ExerciseRequestSettingsQuery, ExerciseRequestSettingsQueryVariables>(ExerciseRequestSettingsDocument, options);\n      }\nexport function useExerciseRequestSettingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ExerciseRequestSettingsQuery, ExerciseRequestSettingsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ExerciseRequestSettingsQuery, ExerciseRequestSettingsQueryVariables>(ExerciseRequestSettingsDocument, options);\n        }\nexport function useExerciseRequestSettingsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ExerciseRequestSettingsQuery, ExerciseRequestSettingsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ExerciseRequestSettingsQuery, ExerciseRequestSettingsQueryVariables>(ExerciseRequestSettingsDocument, options);\n        }\nexport type ExerciseRequestSettingsQueryHookResult = ReturnType<typeof useExerciseRequestSettingsQuery>;\nexport type ExerciseRequestSettingsLazyQueryHookResult = ReturnType<typeof useExerciseRequestSettingsLazyQuery>;\nexport type ExerciseRequestSettingsSuspenseQueryHookResult = ReturnType<typeof useExerciseRequestSettingsSuspenseQuery>;\nexport type ExerciseRequestSettingsQueryResult = Apollo.QueryResult<ExerciseRequestSettingsQuery, ExerciseRequestSettingsQueryVariables>;\nexport function refetchExerciseRequestSettingsQuery(variables: ExerciseRequestSettingsQueryVariables) {\n      return { query: ExerciseRequestSettingsDocument, variables: variables };\n    }\nexport const HasExerciseRequestSettingsDocument: TypedDocumentNode<HasExerciseRequestSettingsQuery, HasExerciseRequestSettingsQueryVariables> = gql`\n  query hasExerciseRequestSettings($organisationId: OrganisationCakeType!) {\n  exerciseRequestSettings(organisation: $organisationId) {\n    id\n  }\n}\n    `;\n\n/**\n * __useHasExerciseRequestSettingsQuery__\n *\n * To run a query within a React component, call `useHasExerciseRequestSettingsQuery` and pass it any options that fit your needs.\n * When your component renders, `useHasExerciseRequestSettingsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useHasExerciseRequestSettingsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useHasExerciseRequestSettingsQuery(baseOptions: Apollo.QueryHookOptions<HasExerciseRequestSettingsQuery, HasExerciseRequestSettingsQueryVariables> & ({ variables: HasExerciseRequestSettingsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<HasExerciseRequestSettingsQuery, HasExerciseRequestSettingsQueryVariables>(HasExerciseRequestSettingsDocument, options);\n      }\nexport function useHasExerciseRequestSettingsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<HasExerciseRequestSettingsQuery, HasExerciseRequestSettingsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<HasExerciseRequestSettingsQuery, HasExerciseRequestSettingsQueryVariables>(HasExerciseRequestSettingsDocument, options);\n        }\nexport function useHasExerciseRequestSettingsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<HasExerciseRequestSettingsQuery, HasExerciseRequestSettingsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<HasExerciseRequestSettingsQuery, HasExerciseRequestSettingsQueryVariables>(HasExerciseRequestSettingsDocument, options);\n        }\nexport type HasExerciseRequestSettingsQueryHookResult = ReturnType<typeof useHasExerciseRequestSettingsQuery>;\nexport type HasExerciseRequestSettingsLazyQueryHookResult = ReturnType<typeof useHasExerciseRequestSettingsLazyQuery>;\nexport type HasExerciseRequestSettingsSuspenseQueryHookResult = ReturnType<typeof useHasExerciseRequestSettingsSuspenseQuery>;\nexport type HasExerciseRequestSettingsQueryResult = Apollo.QueryResult<HasExerciseRequestSettingsQuery, HasExerciseRequestSettingsQueryVariables>;\nexport function refetchHasExerciseRequestSettingsQuery(variables: HasExerciseRequestSettingsQueryVariables) {\n      return { query: HasExerciseRequestSettingsDocument, variables: variables };\n    }\nexport const ExerciseRequestsDocument: TypedDocumentNode<ExerciseRequestsQuery, ExerciseRequestsQueryVariables> = gql`\n  query exerciseRequests($organisation: OrganisationCakeType!, $organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  exerciseRequests(\n    organisation: $organisation\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    pageData {\n      id\n      created\n      status\n      vestingValue\n      taxWithholding\n      recipientReference\n      exerciseTransaction {\n        id\n        transactionDate\n        shareTransaction {\n          id\n          shares\n          unpaid\n        }\n      }\n      shareCertificateId\n      offer {\n        id\n        shareholder {\n          id\n          displayName\n          avatar\n          investorData {\n            email\n          }\n        }\n        exercisePrice\n        currency\n        plan {\n          name\n        }\n        group {\n          sharetype {\n            id\n            name\n            symbol\n          }\n        }\n      }\n      exerciseNotice {\n        id\n      }\n    }\n  }\n  organisation(organisationId: $organisationId) {\n    shareCertificateType\n    lastCertificateNumber\n  }\n}\n    `;\n\n/**\n * __useExerciseRequestsQuery__\n *\n * To run a query within a React component, call `useExerciseRequestsQuery` and pass it any options that fit your needs.\n * When your component renders, `useExerciseRequestsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useExerciseRequestsQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useExerciseRequestsQuery(baseOptions: Apollo.QueryHookOptions<ExerciseRequestsQuery, ExerciseRequestsQueryVariables> & ({ variables: ExerciseRequestsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ExerciseRequestsQuery, ExerciseRequestsQueryVariables>(ExerciseRequestsDocument, options);\n      }\nexport function useExerciseRequestsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ExerciseRequestsQuery, ExerciseRequestsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ExerciseRequestsQuery, ExerciseRequestsQueryVariables>(ExerciseRequestsDocument, options);\n        }\nexport function useExerciseRequestsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ExerciseRequestsQuery, ExerciseRequestsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ExerciseRequestsQuery, ExerciseRequestsQueryVariables>(ExerciseRequestsDocument, options);\n        }\nexport type ExerciseRequestsQueryHookResult = ReturnType<typeof useExerciseRequestsQuery>;\nexport type ExerciseRequestsLazyQueryHookResult = ReturnType<typeof useExerciseRequestsLazyQuery>;\nexport type ExerciseRequestsSuspenseQueryHookResult = ReturnType<typeof useExerciseRequestsSuspenseQuery>;\nexport type ExerciseRequestsQueryResult = Apollo.QueryResult<ExerciseRequestsQuery, ExerciseRequestsQueryVariables>;\nexport function refetchExerciseRequestsQuery(variables: ExerciseRequestsQueryVariables) {\n      return { query: ExerciseRequestsDocument, variables: variables };\n    }\nexport const ApproveExerciseRequestDocument: TypedDocumentNode<ApproveExerciseRequestMutation, ApproveExerciseRequestMutationVariables> = gql`\n  mutation approveExerciseRequest($exerciseRequestId: OptionExerciseRequestCakeType!, $trusteeId: ShareholderCakeType) {\n  approveExerciseRequest(exerciseRequest: $exerciseRequestId, trustee: $trusteeId)\n}\n    `;\nexport type ApproveExerciseRequestMutationFn = Apollo.MutationFunction<ApproveExerciseRequestMutation, ApproveExerciseRequestMutationVariables>;\n\n/**\n * __useApproveExerciseRequestMutation__\n *\n * To run a mutation, you first call `useApproveExerciseRequestMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useApproveExerciseRequestMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [approveExerciseRequestMutation, { data, loading, error }] = useApproveExerciseRequestMutation({\n *   variables: {\n *      exerciseRequestId: // value for 'exerciseRequestId'\n *      trusteeId: // value for 'trusteeId'\n *   },\n * });\n */\nexport function useApproveExerciseRequestMutation(baseOptions?: Apollo.MutationHookOptions<ApproveExerciseRequestMutation, ApproveExerciseRequestMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ApproveExerciseRequestMutation, ApproveExerciseRequestMutationVariables>(ApproveExerciseRequestDocument, options);\n      }\nexport type ApproveExerciseRequestMutationHookResult = ReturnType<typeof useApproveExerciseRequestMutation>;\nexport type ApproveExerciseRequestMutationResult = Apollo.MutationResult<ApproveExerciseRequestMutation>;\nexport type ApproveExerciseRequestMutationOptions = Apollo.BaseMutationOptions<ApproveExerciseRequestMutation, ApproveExerciseRequestMutationVariables>;\nexport const RejectExerciseRequestDocument: TypedDocumentNode<RejectExerciseRequestMutation, RejectExerciseRequestMutationVariables> = gql`\n  mutation rejectExerciseRequest($exerciseRequestId: OptionExerciseRequestCakeType!) {\n  rejectExerciseRequest(exerciseRequest: $exerciseRequestId)\n}\n    `;\nexport type RejectExerciseRequestMutationFn = Apollo.MutationFunction<RejectExerciseRequestMutation, RejectExerciseRequestMutationVariables>;\n\n/**\n * __useRejectExerciseRequestMutation__\n *\n * To run a mutation, you first call `useRejectExerciseRequestMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRejectExerciseRequestMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [rejectExerciseRequestMutation, { data, loading, error }] = useRejectExerciseRequestMutation({\n *   variables: {\n *      exerciseRequestId: // value for 'exerciseRequestId'\n *   },\n * });\n */\nexport function useRejectExerciseRequestMutation(baseOptions?: Apollo.MutationHookOptions<RejectExerciseRequestMutation, RejectExerciseRequestMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RejectExerciseRequestMutation, RejectExerciseRequestMutationVariables>(RejectExerciseRequestDocument, options);\n      }\nexport type RejectExerciseRequestMutationHookResult = ReturnType<typeof useRejectExerciseRequestMutation>;\nexport type RejectExerciseRequestMutationResult = Apollo.MutationResult<RejectExerciseRequestMutation>;\nexport type RejectExerciseRequestMutationOptions = Apollo.BaseMutationOptions<RejectExerciseRequestMutation, RejectExerciseRequestMutationVariables>;\nexport const ConfirmExercisePaymentAndIssueSharesDocument: TypedDocumentNode<ConfirmExercisePaymentAndIssueSharesMutation, ConfirmExercisePaymentAndIssueSharesMutationVariables> = gql`\n  mutation confirmExercisePaymentAndIssueShares($exerciseRequestId: OptionExerciseRequestCakeType!) {\n  confirmExercisePaymentAndIssueShares(exerciseRequest: $exerciseRequestId) {\n    exerciseTransaction {\n      transactionId\n      transactionDate\n      sharetype {\n        id\n        name\n        symbol\n      }\n      shares\n      unpaid\n    }\n  }\n}\n    `;\nexport type ConfirmExercisePaymentAndIssueSharesMutationFn = Apollo.MutationFunction<ConfirmExercisePaymentAndIssueSharesMutation, ConfirmExercisePaymentAndIssueSharesMutationVariables>;\n\n/**\n * __useConfirmExercisePaymentAndIssueSharesMutation__\n *\n * To run a mutation, you first call `useConfirmExercisePaymentAndIssueSharesMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useConfirmExercisePaymentAndIssueSharesMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [confirmExercisePaymentAndIssueSharesMutation, { data, loading, error }] = useConfirmExercisePaymentAndIssueSharesMutation({\n *   variables: {\n *      exerciseRequestId: // value for 'exerciseRequestId'\n *   },\n * });\n */\nexport function useConfirmExercisePaymentAndIssueSharesMutation(baseOptions?: Apollo.MutationHookOptions<ConfirmExercisePaymentAndIssueSharesMutation, ConfirmExercisePaymentAndIssueSharesMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ConfirmExercisePaymentAndIssueSharesMutation, ConfirmExercisePaymentAndIssueSharesMutationVariables>(ConfirmExercisePaymentAndIssueSharesDocument, options);\n      }\nexport type ConfirmExercisePaymentAndIssueSharesMutationHookResult = ReturnType<typeof useConfirmExercisePaymentAndIssueSharesMutation>;\nexport type ConfirmExercisePaymentAndIssueSharesMutationResult = Apollo.MutationResult<ConfirmExercisePaymentAndIssueSharesMutation>;\nexport type ConfirmExercisePaymentAndIssueSharesMutationOptions = Apollo.BaseMutationOptions<ConfirmExercisePaymentAndIssueSharesMutation, ConfirmExercisePaymentAndIssueSharesMutationVariables>;\nexport const GetDataToRequestExerciseSettleOffineDocument: TypedDocumentNode<GetDataToRequestExerciseSettleOffineQuery, GetDataToRequestExerciseSettleOffineQueryVariables> = gql`\n  query getDataToRequestExerciseSettleOffine($organisationId: OrganisationCakeType!, $exerciseRequestId: OptionExerciseRequestCakeType!) {\n  exerciseRequest(exerciseRequest: $exerciseRequestId) {\n    id\n    vestingValue\n    taxWithholding\n    offer {\n      id\n      exercisePrice\n      currency\n    }\n  }\n  getTrustees(organisation: $organisationId) {\n    id\n    displayName\n  }\n}\n    `;\n\n/**\n * __useGetDataToRequestExerciseSettleOffineQuery__\n *\n * To run a query within a React component, call `useGetDataToRequestExerciseSettleOffineQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDataToRequestExerciseSettleOffineQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDataToRequestExerciseSettleOffineQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      exerciseRequestId: // value for 'exerciseRequestId'\n *   },\n * });\n */\nexport function useGetDataToRequestExerciseSettleOffineQuery(baseOptions: Apollo.QueryHookOptions<GetDataToRequestExerciseSettleOffineQuery, GetDataToRequestExerciseSettleOffineQueryVariables> & ({ variables: GetDataToRequestExerciseSettleOffineQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDataToRequestExerciseSettleOffineQuery, GetDataToRequestExerciseSettleOffineQueryVariables>(GetDataToRequestExerciseSettleOffineDocument, options);\n      }\nexport function useGetDataToRequestExerciseSettleOffineLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDataToRequestExerciseSettleOffineQuery, GetDataToRequestExerciseSettleOffineQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDataToRequestExerciseSettleOffineQuery, GetDataToRequestExerciseSettleOffineQueryVariables>(GetDataToRequestExerciseSettleOffineDocument, options);\n        }\nexport function useGetDataToRequestExerciseSettleOffineSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDataToRequestExerciseSettleOffineQuery, GetDataToRequestExerciseSettleOffineQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDataToRequestExerciseSettleOffineQuery, GetDataToRequestExerciseSettleOffineQueryVariables>(GetDataToRequestExerciseSettleOffineDocument, options);\n        }\nexport type GetDataToRequestExerciseSettleOffineQueryHookResult = ReturnType<typeof useGetDataToRequestExerciseSettleOffineQuery>;\nexport type GetDataToRequestExerciseSettleOffineLazyQueryHookResult = ReturnType<typeof useGetDataToRequestExerciseSettleOffineLazyQuery>;\nexport type GetDataToRequestExerciseSettleOffineSuspenseQueryHookResult = ReturnType<typeof useGetDataToRequestExerciseSettleOffineSuspenseQuery>;\nexport type GetDataToRequestExerciseSettleOffineQueryResult = Apollo.QueryResult<GetDataToRequestExerciseSettleOffineQuery, GetDataToRequestExerciseSettleOffineQueryVariables>;\nexport function refetchGetDataToRequestExerciseSettleOffineQuery(variables: GetDataToRequestExerciseSettleOffineQueryVariables) {\n      return { query: GetDataToRequestExerciseSettleOffineDocument, variables: variables };\n    }\nexport const GetTrusteesToRequestExerciseDocument: TypedDocumentNode<GetTrusteesToRequestExerciseQuery, GetTrusteesToRequestExerciseQueryVariables> = gql`\n  query getTrusteesToRequestExercise($organisationId: OrganisationCakeType!, $search: CleanString) {\n  getTrustees(organisation: $organisationId, search: $search) {\n    id\n    displayName\n    avatar\n    employeeData {\n      role\n      level\n    }\n  }\n}\n    `;\n\n/**\n * __useGetTrusteesToRequestExerciseQuery__\n *\n * To run a query within a React component, call `useGetTrusteesToRequestExerciseQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetTrusteesToRequestExerciseQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetTrusteesToRequestExerciseQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetTrusteesToRequestExerciseQuery(baseOptions: Apollo.QueryHookOptions<GetTrusteesToRequestExerciseQuery, GetTrusteesToRequestExerciseQueryVariables> & ({ variables: GetTrusteesToRequestExerciseQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetTrusteesToRequestExerciseQuery, GetTrusteesToRequestExerciseQueryVariables>(GetTrusteesToRequestExerciseDocument, options);\n      }\nexport function useGetTrusteesToRequestExerciseLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetTrusteesToRequestExerciseQuery, GetTrusteesToRequestExerciseQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetTrusteesToRequestExerciseQuery, GetTrusteesToRequestExerciseQueryVariables>(GetTrusteesToRequestExerciseDocument, options);\n        }\nexport function useGetTrusteesToRequestExerciseSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetTrusteesToRequestExerciseQuery, GetTrusteesToRequestExerciseQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetTrusteesToRequestExerciseQuery, GetTrusteesToRequestExerciseQueryVariables>(GetTrusteesToRequestExerciseDocument, options);\n        }\nexport type GetTrusteesToRequestExerciseQueryHookResult = ReturnType<typeof useGetTrusteesToRequestExerciseQuery>;\nexport type GetTrusteesToRequestExerciseLazyQueryHookResult = ReturnType<typeof useGetTrusteesToRequestExerciseLazyQuery>;\nexport type GetTrusteesToRequestExerciseSuspenseQueryHookResult = ReturnType<typeof useGetTrusteesToRequestExerciseSuspenseQuery>;\nexport type GetTrusteesToRequestExerciseQueryResult = Apollo.QueryResult<GetTrusteesToRequestExerciseQuery, GetTrusteesToRequestExerciseQueryVariables>;\nexport function refetchGetTrusteesToRequestExerciseQuery(variables: GetTrusteesToRequestExerciseQueryVariables) {\n      return { query: GetTrusteesToRequestExerciseDocument, variables: variables };\n    }\nexport const SettleExerciseRequestOfflineDocument: TypedDocumentNode<SettleExerciseRequestOfflineMutation, SettleExerciseRequestOfflineMutationVariables> = gql`\n  mutation settleExerciseRequestOffline($exerciseRequestId: OptionExerciseRequestCakeType!, $exerciseDate: Date!, $exerciseNoticeId: DocumentCakeType, $trustee: ShareholderCakeType) {\n  settleExerciseRequestOffline(\n    exerciseRequest: $exerciseRequestId\n    exerciseDate: $exerciseDate\n    exerciseNotice: $exerciseNoticeId\n    trustee: $trustee\n  ) {\n    exerciseTransaction {\n      transactionId\n      transactionDate\n      sharetype {\n        id\n        name\n        symbol\n      }\n      shares\n      unpaid\n    }\n  }\n}\n    `;\nexport type SettleExerciseRequestOfflineMutationFn = Apollo.MutationFunction<SettleExerciseRequestOfflineMutation, SettleExerciseRequestOfflineMutationVariables>;\n\n/**\n * __useSettleExerciseRequestOfflineMutation__\n *\n * To run a mutation, you first call `useSettleExerciseRequestOfflineMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSettleExerciseRequestOfflineMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [settleExerciseRequestOfflineMutation, { data, loading, error }] = useSettleExerciseRequestOfflineMutation({\n *   variables: {\n *      exerciseRequestId: // value for 'exerciseRequestId'\n *      exerciseDate: // value for 'exerciseDate'\n *      exerciseNoticeId: // value for 'exerciseNoticeId'\n *      trustee: // value for 'trustee'\n *   },\n * });\n */\nexport function useSettleExerciseRequestOfflineMutation(baseOptions?: Apollo.MutationHookOptions<SettleExerciseRequestOfflineMutation, SettleExerciseRequestOfflineMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SettleExerciseRequestOfflineMutation, SettleExerciseRequestOfflineMutationVariables>(SettleExerciseRequestOfflineDocument, options);\n      }\nexport type SettleExerciseRequestOfflineMutationHookResult = ReturnType<typeof useSettleExerciseRequestOfflineMutation>;\nexport type SettleExerciseRequestOfflineMutationResult = Apollo.MutationResult<SettleExerciseRequestOfflineMutation>;\nexport type SettleExerciseRequestOfflineMutationOptions = Apollo.BaseMutationOptions<SettleExerciseRequestOfflineMutation, SettleExerciseRequestOfflineMutationVariables>;\nexport const GetPlanToEditRsuDocument: TypedDocumentNode<GetPlanToEditRsuQuery, GetPlanToEditRsuQueryVariables> = gql`\n  query getPlanToEditRSU($organisationId: UUID!, $planId: UUID!) {\n  plan: rsus(organisationId: $organisationId, filterPlan: $planId) {\n    id\n    name\n    vestingValue\n    requireWitness\n    totalVested\n    totalExercised\n    totalLapsed\n    totalGranted\n    totalOffered\n    group: offerGroup {\n      id\n      country\n      sharetype {\n        id\n        name\n        symbol\n      }\n      isEditable\n      requireBoardApproval\n      totalOffered\n      totalGranted\n      totalVested\n      totalLapsed\n      totalExercised\n    }\n  }\n  sharetypes(organisationId: $organisationId) {\n    id\n    name\n    symbol\n  }\n}\n    `;\n\n/**\n * __useGetPlanToEditRsuQuery__\n *\n * To run a query within a React component, call `useGetPlanToEditRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanToEditRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanToEditRsuQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      planId: // value for 'planId'\n *   },\n * });\n */\nexport function useGetPlanToEditRsuQuery(baseOptions: Apollo.QueryHookOptions<GetPlanToEditRsuQuery, GetPlanToEditRsuQueryVariables> & ({ variables: GetPlanToEditRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanToEditRsuQuery, GetPlanToEditRsuQueryVariables>(GetPlanToEditRsuDocument, options);\n      }\nexport function useGetPlanToEditRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanToEditRsuQuery, GetPlanToEditRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanToEditRsuQuery, GetPlanToEditRsuQueryVariables>(GetPlanToEditRsuDocument, options);\n        }\nexport function useGetPlanToEditRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanToEditRsuQuery, GetPlanToEditRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanToEditRsuQuery, GetPlanToEditRsuQueryVariables>(GetPlanToEditRsuDocument, options);\n        }\nexport type GetPlanToEditRsuQueryHookResult = ReturnType<typeof useGetPlanToEditRsuQuery>;\nexport type GetPlanToEditRsuLazyQueryHookResult = ReturnType<typeof useGetPlanToEditRsuLazyQuery>;\nexport type GetPlanToEditRsuSuspenseQueryHookResult = ReturnType<typeof useGetPlanToEditRsuSuspenseQuery>;\nexport type GetPlanToEditRsuQueryResult = Apollo.QueryResult<GetPlanToEditRsuQuery, GetPlanToEditRsuQueryVariables>;\nexport function refetchGetPlanToEditRsuQuery(variables: GetPlanToEditRsuQueryVariables) {\n      return { query: GetPlanToEditRsuDocument, variables: variables };\n    }\nexport const EditRsuDocument: TypedDocumentNode<EditRsuMutation, EditRsuMutationVariables> = gql`\n  mutation editRSU($plan: RsuCakeType!, $name: CleanString!, $vestingValue: PositiveInteger!, $requireWitness: Boolean) {\n  editRsu(\n    plan: $plan\n    name: $name\n    vestingValue: $vestingValue\n    requireWitness: $requireWitness\n  )\n}\n    `;\nexport type EditRsuMutationFn = Apollo.MutationFunction<EditRsuMutation, EditRsuMutationVariables>;\n\n/**\n * __useEditRsuMutation__\n *\n * To run a mutation, you first call `useEditRsuMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditRsuMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editRsuMutation, { data, loading, error }] = useEditRsuMutation({\n *   variables: {\n *      plan: // value for 'plan'\n *      name: // value for 'name'\n *      vestingValue: // value for 'vestingValue'\n *      requireWitness: // value for 'requireWitness'\n *   },\n * });\n */\nexport function useEditRsuMutation(baseOptions?: Apollo.MutationHookOptions<EditRsuMutation, EditRsuMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditRsuMutation, EditRsuMutationVariables>(EditRsuDocument, options);\n      }\nexport type EditRsuMutationHookResult = ReturnType<typeof useEditRsuMutation>;\nexport type EditRsuMutationResult = Apollo.MutationResult<EditRsuMutation>;\nexport type EditRsuMutationOptions = Apollo.BaseMutationOptions<EditRsuMutation, EditRsuMutationVariables>;\nexport const EditGroupAndRsuDocument: TypedDocumentNode<EditGroupAndRsuMutation, EditGroupAndRsuMutationVariables> = gql`\n  mutation editGroupAndRSU($plan: RsuCakeType!, $name: CleanString!, $vestingValue: PositiveInteger!, $group: RsuOfferGroupCakeType!, $sharetype: SharetypeCakeType, $allowNomineeTrust: Boolean, $requireBoardApproval: Boolean, $enforceDisclosurePeriod: Boolean, $requireWitness: Boolean) {\n  editRsu(\n    plan: $plan\n    name: $name\n    vestingValue: $vestingValue\n    requireWitness: $requireWitness\n  )\n  editGroupRsu(\n    group: $group\n    sharetype: $sharetype\n    allowNomineeTrust: $allowNomineeTrust\n    requireBoardApproval: $requireBoardApproval\n    enforceDisclosurePeriod: $enforceDisclosurePeriod\n  )\n}\n    `;\nexport type EditGroupAndRsuMutationFn = Apollo.MutationFunction<EditGroupAndRsuMutation, EditGroupAndRsuMutationVariables>;\n\n/**\n * __useEditGroupAndRsuMutation__\n *\n * To run a mutation, you first call `useEditGroupAndRsuMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditGroupAndRsuMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editGroupAndRsuMutation, { data, loading, error }] = useEditGroupAndRsuMutation({\n *   variables: {\n *      plan: // value for 'plan'\n *      name: // value for 'name'\n *      vestingValue: // value for 'vestingValue'\n *      group: // value for 'group'\n *      sharetype: // value for 'sharetype'\n *      allowNomineeTrust: // value for 'allowNomineeTrust'\n *      requireBoardApproval: // value for 'requireBoardApproval'\n *      enforceDisclosurePeriod: // value for 'enforceDisclosurePeriod'\n *      requireWitness: // value for 'requireWitness'\n *   },\n * });\n */\nexport function useEditGroupAndRsuMutation(baseOptions?: Apollo.MutationHookOptions<EditGroupAndRsuMutation, EditGroupAndRsuMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditGroupAndRsuMutation, EditGroupAndRsuMutationVariables>(EditGroupAndRsuDocument, options);\n      }\nexport type EditGroupAndRsuMutationHookResult = ReturnType<typeof useEditGroupAndRsuMutation>;\nexport type EditGroupAndRsuMutationResult = Apollo.MutationResult<EditGroupAndRsuMutation>;\nexport type EditGroupAndRsuMutationOptions = Apollo.BaseMutationOptions<EditGroupAndRsuMutation, EditGroupAndRsuMutationVariables>;\nexport const DeleteRsuDocument: TypedDocumentNode<DeleteRsuMutation, DeleteRsuMutationVariables> = gql`\n  mutation deleteRSU($plan: RsuCakeType!) {\n  deleteRsu(plan: $plan)\n}\n    `;\nexport type DeleteRsuMutationFn = Apollo.MutationFunction<DeleteRsuMutation, DeleteRsuMutationVariables>;\n\n/**\n * __useDeleteRsuMutation__\n *\n * To run a mutation, you first call `useDeleteRsuMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteRsuMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteRsuMutation, { data, loading, error }] = useDeleteRsuMutation({\n *   variables: {\n *      plan: // value for 'plan'\n *   },\n * });\n */\nexport function useDeleteRsuMutation(baseOptions?: Apollo.MutationHookOptions<DeleteRsuMutation, DeleteRsuMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteRsuMutation, DeleteRsuMutationVariables>(DeleteRsuDocument, options);\n      }\nexport type DeleteRsuMutationHookResult = ReturnType<typeof useDeleteRsuMutation>;\nexport type DeleteRsuMutationResult = Apollo.MutationResult<DeleteRsuMutation>;\nexport type DeleteRsuMutationOptions = Apollo.BaseMutationOptions<DeleteRsuMutation, DeleteRsuMutationVariables>;\nexport const GetPlansRsuDocument: TypedDocumentNode<GetPlansRsuQuery, GetPlansRsuQueryVariables> = gql`\n  query getPlansRSU($organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  plans: rsus(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    id\n    name\n    vestingValue\n    totalExercised\n    totalVested\n    totalLapsed\n    totalOffered\n    group: offerGroup {\n      country\n    }\n  }\n  organisation(organisationId: $organisationId) {\n    fullyDilutedShares\n  }\n}\n    `;\n\n/**\n * __useGetPlansRsuQuery__\n *\n * To run a query within a React component, call `useGetPlansRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlansRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlansRsuQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetPlansRsuQuery(baseOptions: Apollo.QueryHookOptions<GetPlansRsuQuery, GetPlansRsuQueryVariables> & ({ variables: GetPlansRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlansRsuQuery, GetPlansRsuQueryVariables>(GetPlansRsuDocument, options);\n      }\nexport function useGetPlansRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlansRsuQuery, GetPlansRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlansRsuQuery, GetPlansRsuQueryVariables>(GetPlansRsuDocument, options);\n        }\nexport function useGetPlansRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlansRsuQuery, GetPlansRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlansRsuQuery, GetPlansRsuQueryVariables>(GetPlansRsuDocument, options);\n        }\nexport type GetPlansRsuQueryHookResult = ReturnType<typeof useGetPlansRsuQuery>;\nexport type GetPlansRsuLazyQueryHookResult = ReturnType<typeof useGetPlansRsuLazyQuery>;\nexport type GetPlansRsuSuspenseQueryHookResult = ReturnType<typeof useGetPlansRsuSuspenseQuery>;\nexport type GetPlansRsuQueryResult = Apollo.QueryResult<GetPlansRsuQuery, GetPlansRsuQueryVariables>;\nexport function refetchGetPlansRsuQuery(variables: GetPlansRsuQueryVariables) {\n      return { query: GetPlansRsuDocument, variables: variables };\n    }\nexport const GetPlanNamesRsuDocument: TypedDocumentNode<GetPlanNamesRsuQuery, GetPlanNamesRsuQueryVariables> = gql`\n  query getPlanNamesRSU($organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  rsus(organisationId: $organisationId, page: $page, itemsPerPage: $itemsPerPage) {\n    id\n    name\n  }\n}\n    `;\n\n/**\n * __useGetPlanNamesRsuQuery__\n *\n * To run a query within a React component, call `useGetPlanNamesRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanNamesRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanNamesRsuQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetPlanNamesRsuQuery(baseOptions: Apollo.QueryHookOptions<GetPlanNamesRsuQuery, GetPlanNamesRsuQueryVariables> & ({ variables: GetPlanNamesRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanNamesRsuQuery, GetPlanNamesRsuQueryVariables>(GetPlanNamesRsuDocument, options);\n      }\nexport function useGetPlanNamesRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanNamesRsuQuery, GetPlanNamesRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanNamesRsuQuery, GetPlanNamesRsuQueryVariables>(GetPlanNamesRsuDocument, options);\n        }\nexport function useGetPlanNamesRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanNamesRsuQuery, GetPlanNamesRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanNamesRsuQuery, GetPlanNamesRsuQueryVariables>(GetPlanNamesRsuDocument, options);\n        }\nexport type GetPlanNamesRsuQueryHookResult = ReturnType<typeof useGetPlanNamesRsuQuery>;\nexport type GetPlanNamesRsuLazyQueryHookResult = ReturnType<typeof useGetPlanNamesRsuLazyQuery>;\nexport type GetPlanNamesRsuSuspenseQueryHookResult = ReturnType<typeof useGetPlanNamesRsuSuspenseQuery>;\nexport type GetPlanNamesRsuQueryResult = Apollo.QueryResult<GetPlanNamesRsuQuery, GetPlanNamesRsuQueryVariables>;\nexport function refetchGetPlanNamesRsuQuery(variables: GetPlanNamesRsuQueryVariables) {\n      return { query: GetPlanNamesRsuDocument, variables: variables };\n    }\nexport const GetPlanRsuDocument: TypedDocumentNode<GetPlanRsuQuery, GetPlanRsuQueryVariables> = gql`\n  query getPlanRSU($organisationId: UUID!, $planId: UUID!) {\n  plan: rsus(organisationId: $organisationId, filterPlan: $planId) {\n    id\n    name\n    vestingValue\n    commentCount\n    requireWitness\n    totalVested\n    totalExercised\n    totalLapsed\n    totalGranted\n    totalOffered\n    organisation {\n      id\n      created\n      fullyDilutedShares\n      country\n      currency\n      valuationAt {\n        valuation\n      }\n    }\n    documents {\n      id\n      created\n      name\n      file\n      extension\n    }\n    group: offerGroup {\n      id\n      country\n      sharetype {\n        id\n        name\n        symbol\n      }\n      totalOffered\n      totalGranted\n      totalVested\n      totalLapsed\n      totalExercised\n      offerCount\n      offerAcceptedCount\n      defaultPlanRulesTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      defaultOfferLetterTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      planRulesTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      offerLetterTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanRsuQuery__\n *\n * To run a query within a React component, call `useGetPlanRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanRsuQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      planId: // value for 'planId'\n *   },\n * });\n */\nexport function useGetPlanRsuQuery(baseOptions: Apollo.QueryHookOptions<GetPlanRsuQuery, GetPlanRsuQueryVariables> & ({ variables: GetPlanRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanRsuQuery, GetPlanRsuQueryVariables>(GetPlanRsuDocument, options);\n      }\nexport function useGetPlanRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanRsuQuery, GetPlanRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanRsuQuery, GetPlanRsuQueryVariables>(GetPlanRsuDocument, options);\n        }\nexport function useGetPlanRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanRsuQuery, GetPlanRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanRsuQuery, GetPlanRsuQueryVariables>(GetPlanRsuDocument, options);\n        }\nexport type GetPlanRsuQueryHookResult = ReturnType<typeof useGetPlanRsuQuery>;\nexport type GetPlanRsuLazyQueryHookResult = ReturnType<typeof useGetPlanRsuLazyQuery>;\nexport type GetPlanRsuSuspenseQueryHookResult = ReturnType<typeof useGetPlanRsuSuspenseQuery>;\nexport type GetPlanRsuQueryResult = Apollo.QueryResult<GetPlanRsuQuery, GetPlanRsuQueryVariables>;\nexport function refetchGetPlanRsuQuery(variables: GetPlanRsuQueryVariables) {\n      return { query: GetPlanRsuDocument, variables: variables };\n    }\nexport const GetPlanGroupRsuDocument: TypedDocumentNode<GetPlanGroupRsuQuery, GetPlanGroupRsuQueryVariables> = gql`\n  query getPlanGroupRSU($groupId: RsuOfferGroupCakeType!) {\n  group: rsuOfferGroup(group: $groupId) {\n    id\n    country\n    totalGranted\n    totalVested\n    totalLapsed\n    totalExercised\n    totalOffered\n    offerCount\n    offerAcceptedCount\n    allowNomineeTrust\n    offerLetterTemplate {\n      id\n      name\n      contractType\n      status\n      modified\n    }\n    planRulesTemplate {\n      id\n      name\n      contractType\n      status\n      type\n      extension\n      modified\n    }\n    plan {\n      id\n      name\n    }\n    sharetype {\n      id\n      name\n      symbol\n    }\n    disclosurePeriodDays\n    isEditable\n  }\n}\n    `;\n\n/**\n * __useGetPlanGroupRsuQuery__\n *\n * To run a query within a React component, call `useGetPlanGroupRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanGroupRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanGroupRsuQuery({\n *   variables: {\n *      groupId: // value for 'groupId'\n *   },\n * });\n */\nexport function useGetPlanGroupRsuQuery(baseOptions: Apollo.QueryHookOptions<GetPlanGroupRsuQuery, GetPlanGroupRsuQueryVariables> & ({ variables: GetPlanGroupRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanGroupRsuQuery, GetPlanGroupRsuQueryVariables>(GetPlanGroupRsuDocument, options);\n      }\nexport function useGetPlanGroupRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanGroupRsuQuery, GetPlanGroupRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanGroupRsuQuery, GetPlanGroupRsuQueryVariables>(GetPlanGroupRsuDocument, options);\n        }\nexport function useGetPlanGroupRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanGroupRsuQuery, GetPlanGroupRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanGroupRsuQuery, GetPlanGroupRsuQueryVariables>(GetPlanGroupRsuDocument, options);\n        }\nexport type GetPlanGroupRsuQueryHookResult = ReturnType<typeof useGetPlanGroupRsuQuery>;\nexport type GetPlanGroupRsuLazyQueryHookResult = ReturnType<typeof useGetPlanGroupRsuLazyQuery>;\nexport type GetPlanGroupRsuSuspenseQueryHookResult = ReturnType<typeof useGetPlanGroupRsuSuspenseQuery>;\nexport type GetPlanGroupRsuQueryResult = Apollo.QueryResult<GetPlanGroupRsuQuery, GetPlanGroupRsuQueryVariables>;\nexport function refetchGetPlanGroupRsuQuery(variables: GetPlanGroupRsuQueryVariables) {\n      return { query: GetPlanGroupRsuDocument, variables: variables };\n    }\nexport const GetPlanOffersRsuDocument: TypedDocumentNode<GetPlanOffersRsuQuery, GetPlanOffersRsuQueryVariables> = gql`\n  query getPlanOffersRSU($organisationId: UUID!, $filterId: UUID!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $filters: [ListFilterType!], $sort: [CleanString!], $search: String) {\n  offers: rsuPlanOffers(\n    organisationId: $organisationId\n    filterId: $filterId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    filters: $filters\n    sort: $sort\n    search: $search\n  ) {\n    plan {\n      id\n      vestingValue\n      totalOffered\n      totalLapsed\n      organisation {\n        fullyDilutedShares\n      }\n    }\n    count\n    currentPage\n    notSignedUpCount\n    shareholderCount\n    pageData {\n      id\n      modified\n      groupId\n      planId\n      offerLetterId\n      dateGranted\n      vestStartDate\n      emailsOn\n      requireWitness\n      shareholderId\n      shareholderDisplayName\n      shareholderSecondaryName\n      shareholderAvatar\n      shareholderHasLoggedIn\n      shareholderConsideredInvited\n      shEmail\n      stakeholderType: shareholderType\n      isTrust: shareholderIsTrust\n      status\n      softStatus\n      country\n      vestingValue\n      availableToLapse\n      availableToExercise\n      availableToVest\n      vested\n      granted\n      lapsed\n      exercised\n      conversionLockEventId\n      conversionLockEventDescription\n      conversionLockEventDate\n      hasOngoingPauseEvents\n      hasScheduledPauseEvents\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOffersRsuQuery__\n *\n * To run a query within a React component, call `useGetPlanOffersRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOffersRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOffersRsuQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      filterId: // value for 'filterId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      filters: // value for 'filters'\n *      sort: // value for 'sort'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetPlanOffersRsuQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOffersRsuQuery, GetPlanOffersRsuQueryVariables> & ({ variables: GetPlanOffersRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOffersRsuQuery, GetPlanOffersRsuQueryVariables>(GetPlanOffersRsuDocument, options);\n      }\nexport function useGetPlanOffersRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOffersRsuQuery, GetPlanOffersRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOffersRsuQuery, GetPlanOffersRsuQueryVariables>(GetPlanOffersRsuDocument, options);\n        }\nexport function useGetPlanOffersRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOffersRsuQuery, GetPlanOffersRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOffersRsuQuery, GetPlanOffersRsuQueryVariables>(GetPlanOffersRsuDocument, options);\n        }\nexport type GetPlanOffersRsuQueryHookResult = ReturnType<typeof useGetPlanOffersRsuQuery>;\nexport type GetPlanOffersRsuLazyQueryHookResult = ReturnType<typeof useGetPlanOffersRsuLazyQuery>;\nexport type GetPlanOffersRsuSuspenseQueryHookResult = ReturnType<typeof useGetPlanOffersRsuSuspenseQuery>;\nexport type GetPlanOffersRsuQueryResult = Apollo.QueryResult<GetPlanOffersRsuQuery, GetPlanOffersRsuQueryVariables>;\nexport function refetchGetPlanOffersRsuQuery(variables: GetPlanOffersRsuQueryVariables) {\n      return { query: GetPlanOffersRsuDocument, variables: variables };\n    }\nexport const OffersVestingEventsRsuDocument: TypedDocumentNode<OffersVestingEventsRsuQuery, OffersVestingEventsRsuQueryVariables> = gql`\n  query offersVestingEventsRSU($offerIds: [UUID!]!) {\n  offersVestingEvents: rsuOffersVestingEvents(offerIds: $offerIds) {\n    id\n    offerId\n    order\n    vestingValue\n    eventType\n    vestingData {\n      description\n      duration {\n        value\n        granularity\n      }\n      frequency {\n        value\n        granularity\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useOffersVestingEventsRsuQuery__\n *\n * To run a query within a React component, call `useOffersVestingEventsRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `useOffersVestingEventsRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useOffersVestingEventsRsuQuery({\n *   variables: {\n *      offerIds: // value for 'offerIds'\n *   },\n * });\n */\nexport function useOffersVestingEventsRsuQuery(baseOptions: Apollo.QueryHookOptions<OffersVestingEventsRsuQuery, OffersVestingEventsRsuQueryVariables> & ({ variables: OffersVestingEventsRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<OffersVestingEventsRsuQuery, OffersVestingEventsRsuQueryVariables>(OffersVestingEventsRsuDocument, options);\n      }\nexport function useOffersVestingEventsRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OffersVestingEventsRsuQuery, OffersVestingEventsRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<OffersVestingEventsRsuQuery, OffersVestingEventsRsuQueryVariables>(OffersVestingEventsRsuDocument, options);\n        }\nexport function useOffersVestingEventsRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OffersVestingEventsRsuQuery, OffersVestingEventsRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<OffersVestingEventsRsuQuery, OffersVestingEventsRsuQueryVariables>(OffersVestingEventsRsuDocument, options);\n        }\nexport type OffersVestingEventsRsuQueryHookResult = ReturnType<typeof useOffersVestingEventsRsuQuery>;\nexport type OffersVestingEventsRsuLazyQueryHookResult = ReturnType<typeof useOffersVestingEventsRsuLazyQuery>;\nexport type OffersVestingEventsRsuSuspenseQueryHookResult = ReturnType<typeof useOffersVestingEventsRsuSuspenseQuery>;\nexport type OffersVestingEventsRsuQueryResult = Apollo.QueryResult<OffersVestingEventsRsuQuery, OffersVestingEventsRsuQueryVariables>;\nexport function refetchOffersVestingEventsRsuQuery(variables: OffersVestingEventsRsuQueryVariables) {\n      return { query: OffersVestingEventsRsuDocument, variables: variables };\n    }\nexport const GetPlanOffersToCompleteRsuDocument: TypedDocumentNode<GetPlanOffersToCompleteRsuQuery, GetPlanOffersToCompleteRsuQueryVariables> = gql`\n  query getPlanOffersToCompleteRSU($organisationId: UUID!, $offerIds: [UUID]!) {\n  offers: rsuOffersToComplete(\n    organisationId: $organisationId\n    offerIds: $offerIds\n  ) {\n    id\n    vestStartDate\n    country\n    status\n    shareholderDisplayName\n    shareholder: shareholderOpt {\n      id\n      secondaryName\n      avatar\n      recipient {\n        id\n        displayName\n      }\n      investorData {\n        name\n        email\n        jointIndex\n        companyData {\n          signers {\n            name\n            email\n          }\n        }\n      }\n    }\n    offerLetterTemplate {\n      id\n    }\n    group {\n      id\n      country\n      offerLetterTemplate {\n        id\n        name\n        status\n        contractType\n        modified\n      }\n      planRulesTemplate {\n        id\n        name\n        status\n        type\n        contractType\n        modified\n        extension\n      }\n      defaultPlanRulesTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n      defaultOfferLetterTemplate {\n        id\n        name\n        contractType\n        created\n        type\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOffersToCompleteRsuQuery__\n *\n * To run a query within a React component, call `useGetPlanOffersToCompleteRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOffersToCompleteRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOffersToCompleteRsuQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      offerIds: // value for 'offerIds'\n *   },\n * });\n */\nexport function useGetPlanOffersToCompleteRsuQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOffersToCompleteRsuQuery, GetPlanOffersToCompleteRsuQueryVariables> & ({ variables: GetPlanOffersToCompleteRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOffersToCompleteRsuQuery, GetPlanOffersToCompleteRsuQueryVariables>(GetPlanOffersToCompleteRsuDocument, options);\n      }\nexport function useGetPlanOffersToCompleteRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOffersToCompleteRsuQuery, GetPlanOffersToCompleteRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOffersToCompleteRsuQuery, GetPlanOffersToCompleteRsuQueryVariables>(GetPlanOffersToCompleteRsuDocument, options);\n        }\nexport function useGetPlanOffersToCompleteRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOffersToCompleteRsuQuery, GetPlanOffersToCompleteRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOffersToCompleteRsuQuery, GetPlanOffersToCompleteRsuQueryVariables>(GetPlanOffersToCompleteRsuDocument, options);\n        }\nexport type GetPlanOffersToCompleteRsuQueryHookResult = ReturnType<typeof useGetPlanOffersToCompleteRsuQuery>;\nexport type GetPlanOffersToCompleteRsuLazyQueryHookResult = ReturnType<typeof useGetPlanOffersToCompleteRsuLazyQuery>;\nexport type GetPlanOffersToCompleteRsuSuspenseQueryHookResult = ReturnType<typeof useGetPlanOffersToCompleteRsuSuspenseQuery>;\nexport type GetPlanOffersToCompleteRsuQueryResult = Apollo.QueryResult<GetPlanOffersToCompleteRsuQuery, GetPlanOffersToCompleteRsuQueryVariables>;\nexport function refetchGetPlanOffersToCompleteRsuQuery(variables: GetPlanOffersToCompleteRsuQueryVariables) {\n      return { query: GetPlanOffersToCompleteRsuDocument, variables: variables };\n    }\nexport const GetPlanOfferRsuDocument: TypedDocumentNode<GetPlanOfferRsuQuery, GetPlanOfferRsuQueryVariables> = gql`\n  query getPlanOfferRSU($offerId: UUID!) {\n  offer: rsuOffer(offerId: $offerId) {\n    id\n    created\n    modified\n    plan {\n      id\n      name\n      vestingValue\n      totalOffered\n      totalLapsed\n      documents {\n        id\n        name\n        extension\n        created\n        type\n      }\n      organisation {\n        id\n        name\n        logoImage: logoImageLink\n        country\n        currency\n        totalShares\n        created\n        valuationAt {\n          valuation\n        }\n        totalSharesUnexercised\n        fullyDilutedShares\n        valuationVisibleToOptionholders\n      }\n      group: offerGroup {\n        id\n        country\n        sharetype {\n          symbol\n          voting\n          dividend\n        }\n        offerLetterTemplate {\n          id\n          name\n          contractType\n          status\n          modified\n        }\n        planRulesTemplate {\n          id\n          name\n          contractType\n          status\n          type\n          extension\n          modified\n        }\n      }\n    }\n    shareholder {\n      id\n      displayName\n      avatar\n      trustAbn\n      heldInTrust\n      trustName\n      inviteLink\n      computedType\n      investorData {\n        name\n        email\n        phone\n        jointIndex\n        address {\n          line2\n          line1\n          locality\n          administrativeArea1\n          postcode\n          country\n        }\n        companyData {\n          contactPerson\n          identifierType\n          identifierNumber\n          signers {\n            name\n            email\n            role\n          }\n        }\n      }\n      recipient {\n        id\n        displayName\n        avatar\n        trustAbn\n        heldInTrust\n        trustName\n        inviteLink\n        computedType\n        investorData {\n          name\n          email\n          phone\n          jointIndex\n          address {\n            line2\n            line1\n            locality\n            administrativeArea1\n            postcode\n            country\n          }\n          companyData {\n            contactPerson\n            identifierType\n            identifierNumber\n            signers {\n              name\n              email\n              role\n            }\n          }\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOfferRsuQuery__\n *\n * To run a query within a React component, call `useGetPlanOfferRsuQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOfferRsuQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOfferRsuQuery({\n *   variables: {\n *      offerId: // value for 'offerId'\n *   },\n * });\n */\nexport function useGetPlanOfferRsuQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOfferRsuQuery, GetPlanOfferRsuQueryVariables> & ({ variables: GetPlanOfferRsuQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOfferRsuQuery, GetPlanOfferRsuQueryVariables>(GetPlanOfferRsuDocument, options);\n      }\nexport function useGetPlanOfferRsuLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOfferRsuQuery, GetPlanOfferRsuQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOfferRsuQuery, GetPlanOfferRsuQueryVariables>(GetPlanOfferRsuDocument, options);\n        }\nexport function useGetPlanOfferRsuSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOfferRsuQuery, GetPlanOfferRsuQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOfferRsuQuery, GetPlanOfferRsuQueryVariables>(GetPlanOfferRsuDocument, options);\n        }\nexport type GetPlanOfferRsuQueryHookResult = ReturnType<typeof useGetPlanOfferRsuQuery>;\nexport type GetPlanOfferRsuLazyQueryHookResult = ReturnType<typeof useGetPlanOfferRsuLazyQuery>;\nexport type GetPlanOfferRsuSuspenseQueryHookResult = ReturnType<typeof useGetPlanOfferRsuSuspenseQuery>;\nexport type GetPlanOfferRsuQueryResult = Apollo.QueryResult<GetPlanOfferRsuQuery, GetPlanOfferRsuQueryVariables>;\nexport function refetchGetPlanOfferRsuQuery(variables: GetPlanOfferRsuQueryVariables) {\n      return { query: GetPlanOfferRsuDocument, variables: variables };\n    }\nexport const RefreshScanbotStatusDocument: TypedDocumentNode<RefreshScanbotStatusMutation, RefreshScanbotStatusMutationVariables> = gql`\n  mutation refreshScanbotStatus($scanbotDocument: ScanbotDocumentCakeType!) {\n  refreshScanbotStatus(scanbotDocument: $scanbotDocument)\n}\n    `;\nexport type RefreshScanbotStatusMutationFn = Apollo.MutationFunction<RefreshScanbotStatusMutation, RefreshScanbotStatusMutationVariables>;\n\n/**\n * __useRefreshScanbotStatusMutation__\n *\n * To run a mutation, you first call `useRefreshScanbotStatusMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useRefreshScanbotStatusMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [refreshScanbotStatusMutation, { data, loading, error }] = useRefreshScanbotStatusMutation({\n *   variables: {\n *      scanbotDocument: // value for 'scanbotDocument'\n *   },\n * });\n */\nexport function useRefreshScanbotStatusMutation(baseOptions?: Apollo.MutationHookOptions<RefreshScanbotStatusMutation, RefreshScanbotStatusMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<RefreshScanbotStatusMutation, RefreshScanbotStatusMutationVariables>(RefreshScanbotStatusDocument, options);\n      }\nexport type RefreshScanbotStatusMutationHookResult = ReturnType<typeof useRefreshScanbotStatusMutation>;\nexport type RefreshScanbotStatusMutationResult = Apollo.MutationResult<RefreshScanbotStatusMutation>;\nexport type RefreshScanbotStatusMutationOptions = Apollo.BaseMutationOptions<RefreshScanbotStatusMutation, RefreshScanbotStatusMutationVariables>;\nexport const DeleteScanbotDocumentDocument: TypedDocumentNode<DeleteScanbotDocumentMutation, DeleteScanbotDocumentMutationVariables> = gql`\n  mutation deleteScanbotDocument($scanbotDocument: ScanbotDocumentCakeType!) {\n  deleteScanbotDocument(scanbotDocument: $scanbotDocument)\n}\n    `;\nexport type DeleteScanbotDocumentMutationFn = Apollo.MutationFunction<DeleteScanbotDocumentMutation, DeleteScanbotDocumentMutationVariables>;\n\n/**\n * __useDeleteScanbotDocumentMutation__\n *\n * To run a mutation, you first call `useDeleteScanbotDocumentMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteScanbotDocumentMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteScanbotDocumentMutation, { data, loading, error }] = useDeleteScanbotDocumentMutation({\n *   variables: {\n *      scanbotDocument: // value for 'scanbotDocument'\n *   },\n * });\n */\nexport function useDeleteScanbotDocumentMutation(baseOptions?: Apollo.MutationHookOptions<DeleteScanbotDocumentMutation, DeleteScanbotDocumentMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteScanbotDocumentMutation, DeleteScanbotDocumentMutationVariables>(DeleteScanbotDocumentDocument, options);\n      }\nexport type DeleteScanbotDocumentMutationHookResult = ReturnType<typeof useDeleteScanbotDocumentMutation>;\nexport type DeleteScanbotDocumentMutationResult = Apollo.MutationResult<DeleteScanbotDocumentMutation>;\nexport type DeleteScanbotDocumentMutationOptions = Apollo.BaseMutationOptions<DeleteScanbotDocumentMutation, DeleteScanbotDocumentMutationVariables>;\nexport const UploadEditableDocumentDocument: TypedDocumentNode<UploadEditableDocumentMutation, UploadEditableDocumentMutationVariables> = gql`\n  mutation uploadEditableDocument($scanbotDocument: ScanbotDocumentCakeType!, $editableDocument: DocumentCakeType!) {\n  uploadEditableDocument(\n    scanbotDocument: $scanbotDocument\n    editableDocument: $editableDocument\n  )\n}\n    `;\nexport type UploadEditableDocumentMutationFn = Apollo.MutationFunction<UploadEditableDocumentMutation, UploadEditableDocumentMutationVariables>;\n\n/**\n * __useUploadEditableDocumentMutation__\n *\n * To run a mutation, you first call `useUploadEditableDocumentMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUploadEditableDocumentMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [uploadEditableDocumentMutation, { data, loading, error }] = useUploadEditableDocumentMutation({\n *   variables: {\n *      scanbotDocument: // value for 'scanbotDocument'\n *      editableDocument: // value for 'editableDocument'\n *   },\n * });\n */\nexport function useUploadEditableDocumentMutation(baseOptions?: Apollo.MutationHookOptions<UploadEditableDocumentMutation, UploadEditableDocumentMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UploadEditableDocumentMutation, UploadEditableDocumentMutationVariables>(UploadEditableDocumentDocument, options);\n      }\nexport type UploadEditableDocumentMutationHookResult = ReturnType<typeof useUploadEditableDocumentMutation>;\nexport type UploadEditableDocumentMutationResult = Apollo.MutationResult<UploadEditableDocumentMutation>;\nexport type UploadEditableDocumentMutationOptions = Apollo.BaseMutationOptions<UploadEditableDocumentMutation, UploadEditableDocumentMutationVariables>;\nexport const ScanbotDocumentDocument: TypedDocumentNode<ScanbotDocumentQuery, ScanbotDocumentQueryVariables> = gql`\n  query scanbotDocument($scanbotDocument: ScanbotDocumentCakeType!) {\n  scanbotDocument(scanbotDocument: $scanbotDocument) {\n    id\n    created\n    status\n    result\n    document {\n      name\n    }\n    editableDocument {\n      id\n      name\n    }\n  }\n}\n    `;\n\n/**\n * __useScanbotDocumentQuery__\n *\n * To run a query within a React component, call `useScanbotDocumentQuery` and pass it any options that fit your needs.\n * When your component renders, `useScanbotDocumentQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useScanbotDocumentQuery({\n *   variables: {\n *      scanbotDocument: // value for 'scanbotDocument'\n *   },\n * });\n */\nexport function useScanbotDocumentQuery(baseOptions: Apollo.QueryHookOptions<ScanbotDocumentQuery, ScanbotDocumentQueryVariables> & ({ variables: ScanbotDocumentQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ScanbotDocumentQuery, ScanbotDocumentQueryVariables>(ScanbotDocumentDocument, options);\n      }\nexport function useScanbotDocumentLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ScanbotDocumentQuery, ScanbotDocumentQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ScanbotDocumentQuery, ScanbotDocumentQueryVariables>(ScanbotDocumentDocument, options);\n        }\nexport function useScanbotDocumentSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ScanbotDocumentQuery, ScanbotDocumentQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ScanbotDocumentQuery, ScanbotDocumentQueryVariables>(ScanbotDocumentDocument, options);\n        }\nexport type ScanbotDocumentQueryHookResult = ReturnType<typeof useScanbotDocumentQuery>;\nexport type ScanbotDocumentLazyQueryHookResult = ReturnType<typeof useScanbotDocumentLazyQuery>;\nexport type ScanbotDocumentSuspenseQueryHookResult = ReturnType<typeof useScanbotDocumentSuspenseQuery>;\nexport type ScanbotDocumentQueryResult = Apollo.QueryResult<ScanbotDocumentQuery, ScanbotDocumentQueryVariables>;\nexport function refetchScanbotDocumentQuery(variables: ScanbotDocumentQueryVariables) {\n      return { query: ScanbotDocumentDocument, variables: variables };\n    }\nexport const ScanbotDocumentsDocument: TypedDocumentNode<ScanbotDocumentsQuery, ScanbotDocumentsQueryVariables> = gql`\n  query scanbotDocuments($organisation: OrganisationCakeType!) {\n  scanbotDocuments(organisation: $organisation) {\n    id\n    created\n    status\n    result\n    document {\n      name\n    }\n    editableDocument {\n      id\n      name\n    }\n  }\n}\n    `;\n\n/**\n * __useScanbotDocumentsQuery__\n *\n * To run a query within a React component, call `useScanbotDocumentsQuery` and pass it any options that fit your needs.\n * When your component renders, `useScanbotDocumentsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useScanbotDocumentsQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *   },\n * });\n */\nexport function useScanbotDocumentsQuery(baseOptions: Apollo.QueryHookOptions<ScanbotDocumentsQuery, ScanbotDocumentsQueryVariables> & ({ variables: ScanbotDocumentsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ScanbotDocumentsQuery, ScanbotDocumentsQueryVariables>(ScanbotDocumentsDocument, options);\n      }\nexport function useScanbotDocumentsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ScanbotDocumentsQuery, ScanbotDocumentsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ScanbotDocumentsQuery, ScanbotDocumentsQueryVariables>(ScanbotDocumentsDocument, options);\n        }\nexport function useScanbotDocumentsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ScanbotDocumentsQuery, ScanbotDocumentsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ScanbotDocumentsQuery, ScanbotDocumentsQueryVariables>(ScanbotDocumentsDocument, options);\n        }\nexport type ScanbotDocumentsQueryHookResult = ReturnType<typeof useScanbotDocumentsQuery>;\nexport type ScanbotDocumentsLazyQueryHookResult = ReturnType<typeof useScanbotDocumentsLazyQuery>;\nexport type ScanbotDocumentsSuspenseQueryHookResult = ReturnType<typeof useScanbotDocumentsSuspenseQuery>;\nexport type ScanbotDocumentsQueryResult = Apollo.QueryResult<ScanbotDocumentsQuery, ScanbotDocumentsQueryVariables>;\nexport function refetchScanbotDocumentsQuery(variables: ScanbotDocumentsQueryVariables) {\n      return { query: ScanbotDocumentsDocument, variables: variables };\n    }\nexport const CreateShareTransferOfferDocument: TypedDocumentNode<CreateShareTransferOfferMutation, CreateShareTransferOfferMutationVariables> = gql`\n  mutation createShareTransferOffer($shareTransferRound: ShareTransferRoundCakeType!, $fromShareholder: ShareholderCakeType!, $toShareholder: ShareholderCakeType!, $sharetype: SharetypeCakeType!, $shares: PositiveInteger!, $amount: CakeDecimal!) {\n  createShareTransferOffer(\n    shareTransferRound: $shareTransferRound\n    fromShareholder: $fromShareholder\n    toShareholder: $toShareholder\n    sharetype: $sharetype\n    shares: $shares\n    amount: $amount\n  ) {\n    transferOffer {\n      id\n    }\n  }\n}\n    `;\nexport type CreateShareTransferOfferMutationFn = Apollo.MutationFunction<CreateShareTransferOfferMutation, CreateShareTransferOfferMutationVariables>;\n\n/**\n * __useCreateShareTransferOfferMutation__\n *\n * To run a mutation, you first call `useCreateShareTransferOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateShareTransferOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createShareTransferOfferMutation, { data, loading, error }] = useCreateShareTransferOfferMutation({\n *   variables: {\n *      shareTransferRound: // value for 'shareTransferRound'\n *      fromShareholder: // value for 'fromShareholder'\n *      toShareholder: // value for 'toShareholder'\n *      sharetype: // value for 'sharetype'\n *      shares: // value for 'shares'\n *      amount: // value for 'amount'\n *   },\n * });\n */\nexport function useCreateShareTransferOfferMutation(baseOptions?: Apollo.MutationHookOptions<CreateShareTransferOfferMutation, CreateShareTransferOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateShareTransferOfferMutation, CreateShareTransferOfferMutationVariables>(CreateShareTransferOfferDocument, options);\n      }\nexport type CreateShareTransferOfferMutationHookResult = ReturnType<typeof useCreateShareTransferOfferMutation>;\nexport type CreateShareTransferOfferMutationResult = Apollo.MutationResult<CreateShareTransferOfferMutation>;\nexport type CreateShareTransferOfferMutationOptions = Apollo.BaseMutationOptions<CreateShareTransferOfferMutation, CreateShareTransferOfferMutationVariables>;\nexport const EditShareTransferOfferDocument: TypedDocumentNode<EditShareTransferOfferMutation, EditShareTransferOfferMutationVariables> = gql`\n  mutation editShareTransferOffer($transferOffer: ShareTransferOfferCakeType!, $fromShareholder: ShareholderCakeType!, $toShareholder: ShareholderCakeType!, $sharetype: SharetypeCakeType!, $shares: PositiveInteger!, $amount: CakeDecimal!) {\n  editShareTransferOffer(\n    transferOffer: $transferOffer\n    fromShareholder: $fromShareholder\n    toShareholder: $toShareholder\n    sharetype: $sharetype\n    shares: $shares\n    amount: $amount\n  ) {\n    transferOffer {\n      id\n    }\n  }\n}\n    `;\nexport type EditShareTransferOfferMutationFn = Apollo.MutationFunction<EditShareTransferOfferMutation, EditShareTransferOfferMutationVariables>;\n\n/**\n * __useEditShareTransferOfferMutation__\n *\n * To run a mutation, you first call `useEditShareTransferOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditShareTransferOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editShareTransferOfferMutation, { data, loading, error }] = useEditShareTransferOfferMutation({\n *   variables: {\n *      transferOffer: // value for 'transferOffer'\n *      fromShareholder: // value for 'fromShareholder'\n *      toShareholder: // value for 'toShareholder'\n *      sharetype: // value for 'sharetype'\n *      shares: // value for 'shares'\n *      amount: // value for 'amount'\n *   },\n * });\n */\nexport function useEditShareTransferOfferMutation(baseOptions?: Apollo.MutationHookOptions<EditShareTransferOfferMutation, EditShareTransferOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditShareTransferOfferMutation, EditShareTransferOfferMutationVariables>(EditShareTransferOfferDocument, options);\n      }\nexport type EditShareTransferOfferMutationHookResult = ReturnType<typeof useEditShareTransferOfferMutation>;\nexport type EditShareTransferOfferMutationResult = Apollo.MutationResult<EditShareTransferOfferMutation>;\nexport type EditShareTransferOfferMutationOptions = Apollo.BaseMutationOptions<EditShareTransferOfferMutation, EditShareTransferOfferMutationVariables>;\nexport const DeleteShareTransferOfferDocument: TypedDocumentNode<DeleteShareTransferOfferMutation, DeleteShareTransferOfferMutationVariables> = gql`\n  mutation deleteShareTransferOffer($transferOffer: ShareTransferOfferCakeType!) {\n  deleteShareTransferOffer(transferOffer: $transferOffer) {\n    ok\n  }\n}\n    `;\nexport type DeleteShareTransferOfferMutationFn = Apollo.MutationFunction<DeleteShareTransferOfferMutation, DeleteShareTransferOfferMutationVariables>;\n\n/**\n * __useDeleteShareTransferOfferMutation__\n *\n * To run a mutation, you first call `useDeleteShareTransferOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteShareTransferOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteShareTransferOfferMutation, { data, loading, error }] = useDeleteShareTransferOfferMutation({\n *   variables: {\n *      transferOffer: // value for 'transferOffer'\n *   },\n * });\n */\nexport function useDeleteShareTransferOfferMutation(baseOptions?: Apollo.MutationHookOptions<DeleteShareTransferOfferMutation, DeleteShareTransferOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteShareTransferOfferMutation, DeleteShareTransferOfferMutationVariables>(DeleteShareTransferOfferDocument, options);\n      }\nexport type DeleteShareTransferOfferMutationHookResult = ReturnType<typeof useDeleteShareTransferOfferMutation>;\nexport type DeleteShareTransferOfferMutationResult = Apollo.MutationResult<DeleteShareTransferOfferMutation>;\nexport type DeleteShareTransferOfferMutationOptions = Apollo.BaseMutationOptions<DeleteShareTransferOfferMutation, DeleteShareTransferOfferMutationVariables>;\nexport const SettleShareTransferOfferOfflineDocument: TypedDocumentNode<SettleShareTransferOfferOfflineMutation, SettleShareTransferOfferOfflineMutationVariables> = gql`\n  mutation settleShareTransferOfferOffline($transferOffer: ShareTransferOfferCakeType!, $contract: DocumentCakeType) {\n  settleShareTransferOfferOffline(\n    transferOffer: $transferOffer\n    contract: $contract\n  ) {\n    ok\n  }\n}\n    `;\nexport type SettleShareTransferOfferOfflineMutationFn = Apollo.MutationFunction<SettleShareTransferOfferOfflineMutation, SettleShareTransferOfferOfflineMutationVariables>;\n\n/**\n * __useSettleShareTransferOfferOfflineMutation__\n *\n * To run a mutation, you first call `useSettleShareTransferOfferOfflineMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useSettleShareTransferOfferOfflineMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [settleShareTransferOfferOfflineMutation, { data, loading, error }] = useSettleShareTransferOfferOfflineMutation({\n *   variables: {\n *      transferOffer: // value for 'transferOffer'\n *      contract: // value for 'contract'\n *   },\n * });\n */\nexport function useSettleShareTransferOfferOfflineMutation(baseOptions?: Apollo.MutationHookOptions<SettleShareTransferOfferOfflineMutation, SettleShareTransferOfferOfflineMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<SettleShareTransferOfferOfflineMutation, SettleShareTransferOfferOfflineMutationVariables>(SettleShareTransferOfferOfflineDocument, options);\n      }\nexport type SettleShareTransferOfferOfflineMutationHookResult = ReturnType<typeof useSettleShareTransferOfferOfflineMutation>;\nexport type SettleShareTransferOfferOfflineMutationResult = Apollo.MutationResult<SettleShareTransferOfferOfflineMutation>;\nexport type SettleShareTransferOfferOfflineMutationOptions = Apollo.BaseMutationOptions<SettleShareTransferOfferOfflineMutation, SettleShareTransferOfferOfflineMutationVariables>;\nexport const InviteShareTransferOfferDocument: TypedDocumentNode<InviteShareTransferOfferMutation, InviteShareTransferOfferMutationVariables> = gql`\n  mutation inviteShareTransferOffer($transferOffer: ShareTransferOfferCakeType!, $sendInvitationEmail: Boolean!) {\n  inviteShareTransferOffer(\n    transferOffer: $transferOffer\n    sendInvitationEmail: $sendInvitationEmail\n  ) {\n    ok\n  }\n}\n    `;\nexport type InviteShareTransferOfferMutationFn = Apollo.MutationFunction<InviteShareTransferOfferMutation, InviteShareTransferOfferMutationVariables>;\n\n/**\n * __useInviteShareTransferOfferMutation__\n *\n * To run a mutation, you first call `useInviteShareTransferOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useInviteShareTransferOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [inviteShareTransferOfferMutation, { data, loading, error }] = useInviteShareTransferOfferMutation({\n *   variables: {\n *      transferOffer: // value for 'transferOffer'\n *      sendInvitationEmail: // value for 'sendInvitationEmail'\n *   },\n * });\n */\nexport function useInviteShareTransferOfferMutation(baseOptions?: Apollo.MutationHookOptions<InviteShareTransferOfferMutation, InviteShareTransferOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<InviteShareTransferOfferMutation, InviteShareTransferOfferMutationVariables>(InviteShareTransferOfferDocument, options);\n      }\nexport type InviteShareTransferOfferMutationHookResult = ReturnType<typeof useInviteShareTransferOfferMutation>;\nexport type InviteShareTransferOfferMutationResult = Apollo.MutationResult<InviteShareTransferOfferMutation>;\nexport type InviteShareTransferOfferMutationOptions = Apollo.BaseMutationOptions<InviteShareTransferOfferMutation, InviteShareTransferOfferMutationVariables>;\nexport const UpdateShareTransferOfferPaymentStatusDocument: TypedDocumentNode<UpdateShareTransferOfferPaymentStatusMutation, UpdateShareTransferOfferPaymentStatusMutationVariables> = gql`\n  mutation updateShareTransferOfferPaymentStatus($transferOffer: ShareTransferOfferCakeType!, $paid: CakeDecimal!) {\n  updateShareTransferOfferPaymentStatus(\n    transferOffer: $transferOffer\n    paid: $paid\n  ) {\n    ok\n  }\n}\n    `;\nexport type UpdateShareTransferOfferPaymentStatusMutationFn = Apollo.MutationFunction<UpdateShareTransferOfferPaymentStatusMutation, UpdateShareTransferOfferPaymentStatusMutationVariables>;\n\n/**\n * __useUpdateShareTransferOfferPaymentStatusMutation__\n *\n * To run a mutation, you first call `useUpdateShareTransferOfferPaymentStatusMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useUpdateShareTransferOfferPaymentStatusMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [updateShareTransferOfferPaymentStatusMutation, { data, loading, error }] = useUpdateShareTransferOfferPaymentStatusMutation({\n *   variables: {\n *      transferOffer: // value for 'transferOffer'\n *      paid: // value for 'paid'\n *   },\n * });\n */\nexport function useUpdateShareTransferOfferPaymentStatusMutation(baseOptions?: Apollo.MutationHookOptions<UpdateShareTransferOfferPaymentStatusMutation, UpdateShareTransferOfferPaymentStatusMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<UpdateShareTransferOfferPaymentStatusMutation, UpdateShareTransferOfferPaymentStatusMutationVariables>(UpdateShareTransferOfferPaymentStatusDocument, options);\n      }\nexport type UpdateShareTransferOfferPaymentStatusMutationHookResult = ReturnType<typeof useUpdateShareTransferOfferPaymentStatusMutation>;\nexport type UpdateShareTransferOfferPaymentStatusMutationResult = Apollo.MutationResult<UpdateShareTransferOfferPaymentStatusMutation>;\nexport type UpdateShareTransferOfferPaymentStatusMutationOptions = Apollo.BaseMutationOptions<UpdateShareTransferOfferPaymentStatusMutation, UpdateShareTransferOfferPaymentStatusMutationVariables>;\nexport const CompleteShareTransferOfferDocument: TypedDocumentNode<CompleteShareTransferOfferMutation, CompleteShareTransferOfferMutationVariables> = gql`\n  mutation completeShareTransferOffer($transferOffer: ShareTransferOfferCakeType!, $transferDate: Date!, $certificateCount: PositiveInteger!) {\n  completeShareTransferOffer(\n    transferOffer: $transferOffer\n    transferDate: $transferDate\n    certificateCount: $certificateCount\n  ) {\n    ok\n  }\n}\n    `;\nexport type CompleteShareTransferOfferMutationFn = Apollo.MutationFunction<CompleteShareTransferOfferMutation, CompleteShareTransferOfferMutationVariables>;\n\n/**\n * __useCompleteShareTransferOfferMutation__\n *\n * To run a mutation, you first call `useCompleteShareTransferOfferMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCompleteShareTransferOfferMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [completeShareTransferOfferMutation, { data, loading, error }] = useCompleteShareTransferOfferMutation({\n *   variables: {\n *      transferOffer: // value for 'transferOffer'\n *      transferDate: // value for 'transferDate'\n *      certificateCount: // value for 'certificateCount'\n *   },\n * });\n */\nexport function useCompleteShareTransferOfferMutation(baseOptions?: Apollo.MutationHookOptions<CompleteShareTransferOfferMutation, CompleteShareTransferOfferMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CompleteShareTransferOfferMutation, CompleteShareTransferOfferMutationVariables>(CompleteShareTransferOfferDocument, options);\n      }\nexport type CompleteShareTransferOfferMutationHookResult = ReturnType<typeof useCompleteShareTransferOfferMutation>;\nexport type CompleteShareTransferOfferMutationResult = Apollo.MutationResult<CompleteShareTransferOfferMutation>;\nexport type CompleteShareTransferOfferMutationOptions = Apollo.BaseMutationOptions<CompleteShareTransferOfferMutation, CompleteShareTransferOfferMutationVariables>;\nexport const GetShareTransferOffersDocument: TypedDocumentNode<GetShareTransferOffersQuery, GetShareTransferOffersQueryVariables> = gql`\n  query getShareTransferOffers($transferRound: ShareTransferRoundCakeType!) {\n  shareTransferOffers(transferRound: $transferRound) {\n    count\n    currentPage\n    pageData {\n      id\n      fromShareholder {\n        id\n        displayName\n        secondaryName\n        avatar\n        inviteLink\n        investorData {\n          name\n          email\n          jointIndex\n          companyData {\n            signers {\n              name\n              email\n            }\n          }\n        }\n      }\n      toShareholder {\n        id\n        displayName\n        secondaryName\n        avatar\n        inviteLink\n        investorData {\n          name\n          email\n          jointIndex\n          companyData {\n            signers {\n              name\n              email\n            }\n          }\n        }\n      }\n      sharetype {\n        id\n        name\n        symbol\n      }\n      shares\n      amount\n      shareTransferAgreementContract {\n        id\n        name\n        contractType\n        signatures {\n          name\n          email\n          status\n          extra\n        }\n      }\n      offlineContract {\n        id\n        name\n        contractType\n      }\n      status\n      shareTransferRound {\n        id\n        shareTransferAgreementTemplate {\n          id\n          name\n          status\n          contractType\n        }\n        organisation {\n          lastCertificateNumber\n        }\n      }\n      fromShareholderConfirmed\n      toShareholderConfirmed\n    }\n  }\n}\n    `;\n\n/**\n * __useGetShareTransferOffersQuery__\n *\n * To run a query within a React component, call `useGetShareTransferOffersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetShareTransferOffersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetShareTransferOffersQuery({\n *   variables: {\n *      transferRound: // value for 'transferRound'\n *   },\n * });\n */\nexport function useGetShareTransferOffersQuery(baseOptions: Apollo.QueryHookOptions<GetShareTransferOffersQuery, GetShareTransferOffersQueryVariables> & ({ variables: GetShareTransferOffersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetShareTransferOffersQuery, GetShareTransferOffersQueryVariables>(GetShareTransferOffersDocument, options);\n      }\nexport function useGetShareTransferOffersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetShareTransferOffersQuery, GetShareTransferOffersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetShareTransferOffersQuery, GetShareTransferOffersQueryVariables>(GetShareTransferOffersDocument, options);\n        }\nexport function useGetShareTransferOffersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetShareTransferOffersQuery, GetShareTransferOffersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetShareTransferOffersQuery, GetShareTransferOffersQueryVariables>(GetShareTransferOffersDocument, options);\n        }\nexport type GetShareTransferOffersQueryHookResult = ReturnType<typeof useGetShareTransferOffersQuery>;\nexport type GetShareTransferOffersLazyQueryHookResult = ReturnType<typeof useGetShareTransferOffersLazyQuery>;\nexport type GetShareTransferOffersSuspenseQueryHookResult = ReturnType<typeof useGetShareTransferOffersSuspenseQuery>;\nexport type GetShareTransferOffersQueryResult = Apollo.QueryResult<GetShareTransferOffersQuery, GetShareTransferOffersQueryVariables>;\nexport function refetchGetShareTransferOffersQuery(variables: GetShareTransferOffersQueryVariables) {\n      return { query: GetShareTransferOffersDocument, variables: variables };\n    }\nexport const CreateShareTransferRoundDocument: TypedDocumentNode<CreateShareTransferRoundMutation, CreateShareTransferRoundMutationVariables> = gql`\n  mutation createShareTransferRound($organisation: OrganisationCakeType!, $name: CleanString!) {\n  createShareTransferRound(organisation: $organisation, name: $name) {\n    transferRound {\n      id\n    }\n  }\n}\n    `;\nexport type CreateShareTransferRoundMutationFn = Apollo.MutationFunction<CreateShareTransferRoundMutation, CreateShareTransferRoundMutationVariables>;\n\n/**\n * __useCreateShareTransferRoundMutation__\n *\n * To run a mutation, you first call `useCreateShareTransferRoundMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateShareTransferRoundMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createShareTransferRoundMutation, { data, loading, error }] = useCreateShareTransferRoundMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      name: // value for 'name'\n *   },\n * });\n */\nexport function useCreateShareTransferRoundMutation(baseOptions?: Apollo.MutationHookOptions<CreateShareTransferRoundMutation, CreateShareTransferRoundMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateShareTransferRoundMutation, CreateShareTransferRoundMutationVariables>(CreateShareTransferRoundDocument, options);\n      }\nexport type CreateShareTransferRoundMutationHookResult = ReturnType<typeof useCreateShareTransferRoundMutation>;\nexport type CreateShareTransferRoundMutationResult = Apollo.MutationResult<CreateShareTransferRoundMutation>;\nexport type CreateShareTransferRoundMutationOptions = Apollo.BaseMutationOptions<CreateShareTransferRoundMutation, CreateShareTransferRoundMutationVariables>;\nexport const EditShareTransferRoundDocument: TypedDocumentNode<EditShareTransferRoundMutation, EditShareTransferRoundMutationVariables> = gql`\n  mutation editShareTransferRound($transferRound: ShareTransferRoundCakeType!, $name: CleanString!) {\n  editShareTransferRound(transferRound: $transferRound, name: $name) {\n    transferRound {\n      id\n    }\n  }\n}\n    `;\nexport type EditShareTransferRoundMutationFn = Apollo.MutationFunction<EditShareTransferRoundMutation, EditShareTransferRoundMutationVariables>;\n\n/**\n * __useEditShareTransferRoundMutation__\n *\n * To run a mutation, you first call `useEditShareTransferRoundMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditShareTransferRoundMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editShareTransferRoundMutation, { data, loading, error }] = useEditShareTransferRoundMutation({\n *   variables: {\n *      transferRound: // value for 'transferRound'\n *      name: // value for 'name'\n *   },\n * });\n */\nexport function useEditShareTransferRoundMutation(baseOptions?: Apollo.MutationHookOptions<EditShareTransferRoundMutation, EditShareTransferRoundMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditShareTransferRoundMutation, EditShareTransferRoundMutationVariables>(EditShareTransferRoundDocument, options);\n      }\nexport type EditShareTransferRoundMutationHookResult = ReturnType<typeof useEditShareTransferRoundMutation>;\nexport type EditShareTransferRoundMutationResult = Apollo.MutationResult<EditShareTransferRoundMutation>;\nexport type EditShareTransferRoundMutationOptions = Apollo.BaseMutationOptions<EditShareTransferRoundMutation, EditShareTransferRoundMutationVariables>;\nexport const DeleteShareTransferRoundDocument: TypedDocumentNode<DeleteShareTransferRoundMutation, DeleteShareTransferRoundMutationVariables> = gql`\n  mutation deleteShareTransferRound($transferRound: ShareTransferRoundCakeType!) {\n  deleteShareTransferRound(transferRound: $transferRound) {\n    ok\n  }\n}\n    `;\nexport type DeleteShareTransferRoundMutationFn = Apollo.MutationFunction<DeleteShareTransferRoundMutation, DeleteShareTransferRoundMutationVariables>;\n\n/**\n * __useDeleteShareTransferRoundMutation__\n *\n * To run a mutation, you first call `useDeleteShareTransferRoundMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteShareTransferRoundMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteShareTransferRoundMutation, { data, loading, error }] = useDeleteShareTransferRoundMutation({\n *   variables: {\n *      transferRound: // value for 'transferRound'\n *   },\n * });\n */\nexport function useDeleteShareTransferRoundMutation(baseOptions?: Apollo.MutationHookOptions<DeleteShareTransferRoundMutation, DeleteShareTransferRoundMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteShareTransferRoundMutation, DeleteShareTransferRoundMutationVariables>(DeleteShareTransferRoundDocument, options);\n      }\nexport type DeleteShareTransferRoundMutationHookResult = ReturnType<typeof useDeleteShareTransferRoundMutation>;\nexport type DeleteShareTransferRoundMutationResult = Apollo.MutationResult<DeleteShareTransferRoundMutation>;\nexport type DeleteShareTransferRoundMutationOptions = Apollo.BaseMutationOptions<DeleteShareTransferRoundMutation, DeleteShareTransferRoundMutationVariables>;\nexport const GetShareTransferRoundsAndTransfersDocument: TypedDocumentNode<GetShareTransferRoundsAndTransfersQuery, GetShareTransferRoundsAndTransfersQueryVariables> = gql`\n  query getShareTransferRoundsAndTransfers($organisation: OrganisationCakeType!, $organisationId: UUID!) {\n  shareTransferRounds(organisation: $organisation) {\n    count\n    currentPage\n    pageData {\n      id\n      name\n      offerCount\n    }\n  }\n  shareholdersWithShareholdings(\n    organisationId: $organisationId\n    page: 1\n    itemsPerPage: 1\n  ) {\n    count\n  }\n  organisationShareholdingTransactions(\n    organisationId: $organisationId\n    page: 1\n    itemsPerPage: 1\n    filterType: \"TRANSFER\"\n  ) {\n    count\n  }\n}\n    `;\n\n/**\n * __useGetShareTransferRoundsAndTransfersQuery__\n *\n * To run a query within a React component, call `useGetShareTransferRoundsAndTransfersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetShareTransferRoundsAndTransfersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetShareTransferRoundsAndTransfersQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGetShareTransferRoundsAndTransfersQuery(baseOptions: Apollo.QueryHookOptions<GetShareTransferRoundsAndTransfersQuery, GetShareTransferRoundsAndTransfersQueryVariables> & ({ variables: GetShareTransferRoundsAndTransfersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetShareTransferRoundsAndTransfersQuery, GetShareTransferRoundsAndTransfersQueryVariables>(GetShareTransferRoundsAndTransfersDocument, options);\n      }\nexport function useGetShareTransferRoundsAndTransfersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetShareTransferRoundsAndTransfersQuery, GetShareTransferRoundsAndTransfersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetShareTransferRoundsAndTransfersQuery, GetShareTransferRoundsAndTransfersQueryVariables>(GetShareTransferRoundsAndTransfersDocument, options);\n        }\nexport function useGetShareTransferRoundsAndTransfersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetShareTransferRoundsAndTransfersQuery, GetShareTransferRoundsAndTransfersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetShareTransferRoundsAndTransfersQuery, GetShareTransferRoundsAndTransfersQueryVariables>(GetShareTransferRoundsAndTransfersDocument, options);\n        }\nexport type GetShareTransferRoundsAndTransfersQueryHookResult = ReturnType<typeof useGetShareTransferRoundsAndTransfersQuery>;\nexport type GetShareTransferRoundsAndTransfersLazyQueryHookResult = ReturnType<typeof useGetShareTransferRoundsAndTransfersLazyQuery>;\nexport type GetShareTransferRoundsAndTransfersSuspenseQueryHookResult = ReturnType<typeof useGetShareTransferRoundsAndTransfersSuspenseQuery>;\nexport type GetShareTransferRoundsAndTransfersQueryResult = Apollo.QueryResult<GetShareTransferRoundsAndTransfersQuery, GetShareTransferRoundsAndTransfersQueryVariables>;\nexport function refetchGetShareTransferRoundsAndTransfersQuery(variables: GetShareTransferRoundsAndTransfersQueryVariables) {\n      return { query: GetShareTransferRoundsAndTransfersDocument, variables: variables };\n    }\nexport const GetShareTransferRoundDocument: TypedDocumentNode<GetShareTransferRoundQuery, GetShareTransferRoundQueryVariables> = gql`\n  query getShareTransferRound($organisationId: UUID!, $organisation: OrganisationCakeType!, $filterRound: UUID) {\n  shareTransferRounds(organisation: $organisation, filterRound: $filterRound) {\n    count\n    currentPage\n    pageData {\n      id\n      name\n      offerCount\n      shareTransferAgreementTemplate {\n        id\n        name\n        status\n        contractType\n      }\n      documents {\n        id\n        created\n        name\n        file\n        extension\n      }\n    }\n  }\n  officeholders(organisationId: $organisationId, filterSigners: true) {\n    id\n    name\n    email\n    avatar\n    roles {\n      role\n      name\n    }\n    signer\n  }\n}\n    `;\n\n/**\n * __useGetShareTransferRoundQuery__\n *\n * To run a query within a React component, call `useGetShareTransferRoundQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetShareTransferRoundQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetShareTransferRoundQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      organisation: // value for 'organisation'\n *      filterRound: // value for 'filterRound'\n *   },\n * });\n */\nexport function useGetShareTransferRoundQuery(baseOptions: Apollo.QueryHookOptions<GetShareTransferRoundQuery, GetShareTransferRoundQueryVariables> & ({ variables: GetShareTransferRoundQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetShareTransferRoundQuery, GetShareTransferRoundQueryVariables>(GetShareTransferRoundDocument, options);\n      }\nexport function useGetShareTransferRoundLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetShareTransferRoundQuery, GetShareTransferRoundQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetShareTransferRoundQuery, GetShareTransferRoundQueryVariables>(GetShareTransferRoundDocument, options);\n        }\nexport function useGetShareTransferRoundSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetShareTransferRoundQuery, GetShareTransferRoundQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetShareTransferRoundQuery, GetShareTransferRoundQueryVariables>(GetShareTransferRoundDocument, options);\n        }\nexport type GetShareTransferRoundQueryHookResult = ReturnType<typeof useGetShareTransferRoundQuery>;\nexport type GetShareTransferRoundLazyQueryHookResult = ReturnType<typeof useGetShareTransferRoundLazyQuery>;\nexport type GetShareTransferRoundSuspenseQueryHookResult = ReturnType<typeof useGetShareTransferRoundSuspenseQuery>;\nexport type GetShareTransferRoundQueryResult = Apollo.QueryResult<GetShareTransferRoundQuery, GetShareTransferRoundQueryVariables>;\nexport function refetchGetShareTransferRoundQuery(variables: GetShareTransferRoundQueryVariables) {\n      return { query: GetShareTransferRoundDocument, variables: variables };\n    }\nexport const CreateShareTransferRoundTemplateDocument: TypedDocumentNode<CreateShareTransferRoundTemplateMutation, CreateShareTransferRoundTemplateMutationVariables> = gql`\n  mutation createShareTransferRoundTemplate($transferRound: ShareTransferRoundCakeType!, $templateType: CleanString!, $name: String!, $baseTemplate: DocumentCakeType) {\n  createShareTransferRoundTemplate(\n    transferRound: $transferRound\n    templateType: $templateType\n    name: $name\n    baseTemplate: $baseTemplate\n  ) {\n    ok\n  }\n}\n    `;\nexport type CreateShareTransferRoundTemplateMutationFn = Apollo.MutationFunction<CreateShareTransferRoundTemplateMutation, CreateShareTransferRoundTemplateMutationVariables>;\n\n/**\n * __useCreateShareTransferRoundTemplateMutation__\n *\n * To run a mutation, you first call `useCreateShareTransferRoundTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateShareTransferRoundTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createShareTransferRoundTemplateMutation, { data, loading, error }] = useCreateShareTransferRoundTemplateMutation({\n *   variables: {\n *      transferRound: // value for 'transferRound'\n *      templateType: // value for 'templateType'\n *      name: // value for 'name'\n *      baseTemplate: // value for 'baseTemplate'\n *   },\n * });\n */\nexport function useCreateShareTransferRoundTemplateMutation(baseOptions?: Apollo.MutationHookOptions<CreateShareTransferRoundTemplateMutation, CreateShareTransferRoundTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateShareTransferRoundTemplateMutation, CreateShareTransferRoundTemplateMutationVariables>(CreateShareTransferRoundTemplateDocument, options);\n      }\nexport type CreateShareTransferRoundTemplateMutationHookResult = ReturnType<typeof useCreateShareTransferRoundTemplateMutation>;\nexport type CreateShareTransferRoundTemplateMutationResult = Apollo.MutationResult<CreateShareTransferRoundTemplateMutation>;\nexport type CreateShareTransferRoundTemplateMutationOptions = Apollo.BaseMutationOptions<CreateShareTransferRoundTemplateMutation, CreateShareTransferRoundTemplateMutationVariables>;\nexport const ShareholderAvailableSharesToTransferDocument: TypedDocumentNode<ShareholderAvailableSharesToTransferQuery, ShareholderAvailableSharesToTransferQueryVariables> = gql`\n  query shareholderAvailableSharesToTransfer($shareholder: ShareholderCakeType!, $sharetype: SharetypeCakeType!, $transferDate: Date, $beneficiary: ShareholderCakeType) {\n  shareholderAvailableSharesToTransfer(\n    shareholder: $shareholder\n    sharetype: $sharetype\n    transferDate: $transferDate\n    beneficiary: $beneficiary\n  )\n}\n    `;\n\n/**\n * __useShareholderAvailableSharesToTransferQuery__\n *\n * To run a query within a React component, call `useShareholderAvailableSharesToTransferQuery` and pass it any options that fit your needs.\n * When your component renders, `useShareholderAvailableSharesToTransferQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useShareholderAvailableSharesToTransferQuery({\n *   variables: {\n *      shareholder: // value for 'shareholder'\n *      sharetype: // value for 'sharetype'\n *      transferDate: // value for 'transferDate'\n *      beneficiary: // value for 'beneficiary'\n *   },\n * });\n */\nexport function useShareholderAvailableSharesToTransferQuery(baseOptions: Apollo.QueryHookOptions<ShareholderAvailableSharesToTransferQuery, ShareholderAvailableSharesToTransferQueryVariables> & ({ variables: ShareholderAvailableSharesToTransferQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<ShareholderAvailableSharesToTransferQuery, ShareholderAvailableSharesToTransferQueryVariables>(ShareholderAvailableSharesToTransferDocument, options);\n      }\nexport function useShareholderAvailableSharesToTransferLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ShareholderAvailableSharesToTransferQuery, ShareholderAvailableSharesToTransferQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<ShareholderAvailableSharesToTransferQuery, ShareholderAvailableSharesToTransferQueryVariables>(ShareholderAvailableSharesToTransferDocument, options);\n        }\nexport function useShareholderAvailableSharesToTransferSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ShareholderAvailableSharesToTransferQuery, ShareholderAvailableSharesToTransferQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<ShareholderAvailableSharesToTransferQuery, ShareholderAvailableSharesToTransferQueryVariables>(ShareholderAvailableSharesToTransferDocument, options);\n        }\nexport type ShareholderAvailableSharesToTransferQueryHookResult = ReturnType<typeof useShareholderAvailableSharesToTransferQuery>;\nexport type ShareholderAvailableSharesToTransferLazyQueryHookResult = ReturnType<typeof useShareholderAvailableSharesToTransferLazyQuery>;\nexport type ShareholderAvailableSharesToTransferSuspenseQueryHookResult = ReturnType<typeof useShareholderAvailableSharesToTransferSuspenseQuery>;\nexport type ShareholderAvailableSharesToTransferQueryResult = Apollo.QueryResult<ShareholderAvailableSharesToTransferQuery, ShareholderAvailableSharesToTransferQueryVariables>;\nexport function refetchShareholderAvailableSharesToTransferQuery(variables: ShareholderAvailableSharesToTransferQueryVariables) {\n      return { query: ShareholderAvailableSharesToTransferDocument, variables: variables };\n    }\nexport const DeleteShareTransferRoundTemplateDocument: TypedDocumentNode<DeleteShareTransferRoundTemplateMutation, DeleteShareTransferRoundTemplateMutationVariables> = gql`\n  mutation deleteShareTransferRoundTemplate($transferRound: ShareTransferRoundCakeType!, $templateType: CleanString!) {\n  deleteShareTransferRoundTemplate(\n    transferRound: $transferRound\n    templateType: $templateType\n  ) {\n    ok\n  }\n}\n    `;\nexport type DeleteShareTransferRoundTemplateMutationFn = Apollo.MutationFunction<DeleteShareTransferRoundTemplateMutation, DeleteShareTransferRoundTemplateMutationVariables>;\n\n/**\n * __useDeleteShareTransferRoundTemplateMutation__\n *\n * To run a mutation, you first call `useDeleteShareTransferRoundTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteShareTransferRoundTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteShareTransferRoundTemplateMutation, { data, loading, error }] = useDeleteShareTransferRoundTemplateMutation({\n *   variables: {\n *      transferRound: // value for 'transferRound'\n *      templateType: // value for 'templateType'\n *   },\n * });\n */\nexport function useDeleteShareTransferRoundTemplateMutation(baseOptions?: Apollo.MutationHookOptions<DeleteShareTransferRoundTemplateMutation, DeleteShareTransferRoundTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteShareTransferRoundTemplateMutation, DeleteShareTransferRoundTemplateMutationVariables>(DeleteShareTransferRoundTemplateDocument, options);\n      }\nexport type DeleteShareTransferRoundTemplateMutationHookResult = ReturnType<typeof useDeleteShareTransferRoundTemplateMutation>;\nexport type DeleteShareTransferRoundTemplateMutationResult = Apollo.MutationResult<DeleteShareTransferRoundTemplateMutation>;\nexport type DeleteShareTransferRoundTemplateMutationOptions = Apollo.BaseMutationOptions<DeleteShareTransferRoundTemplateMutation, DeleteShareTransferRoundTemplateMutationVariables>;\nexport const GetPotentialTransferSendersDocument: TypedDocumentNode<GetPotentialTransferSendersQuery, GetPotentialTransferSendersQueryVariables> = gql`\n  query getPotentialTransferSenders($organisationId: OrganisationCakeType!, $search: CleanString, $page: Int!, $itemsPerPage: Int) {\n  getPotentialTransferSenders(\n    organisation: $organisationId\n    search: $search\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    pageData {\n      id\n      displayName\n      secondaryId\n      secondaryName\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPotentialTransferSendersQuery__\n *\n * To run a query within a React component, call `useGetPotentialTransferSendersQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPotentialTransferSendersQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPotentialTransferSendersQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      search: // value for 'search'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetPotentialTransferSendersQuery(baseOptions: Apollo.QueryHookOptions<GetPotentialTransferSendersQuery, GetPotentialTransferSendersQueryVariables> & ({ variables: GetPotentialTransferSendersQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPotentialTransferSendersQuery, GetPotentialTransferSendersQueryVariables>(GetPotentialTransferSendersDocument, options);\n      }\nexport function useGetPotentialTransferSendersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPotentialTransferSendersQuery, GetPotentialTransferSendersQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPotentialTransferSendersQuery, GetPotentialTransferSendersQueryVariables>(GetPotentialTransferSendersDocument, options);\n        }\nexport function useGetPotentialTransferSendersSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPotentialTransferSendersQuery, GetPotentialTransferSendersQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPotentialTransferSendersQuery, GetPotentialTransferSendersQueryVariables>(GetPotentialTransferSendersDocument, options);\n        }\nexport type GetPotentialTransferSendersQueryHookResult = ReturnType<typeof useGetPotentialTransferSendersQuery>;\nexport type GetPotentialTransferSendersLazyQueryHookResult = ReturnType<typeof useGetPotentialTransferSendersLazyQuery>;\nexport type GetPotentialTransferSendersSuspenseQueryHookResult = ReturnType<typeof useGetPotentialTransferSendersSuspenseQuery>;\nexport type GetPotentialTransferSendersQueryResult = Apollo.QueryResult<GetPotentialTransferSendersQuery, GetPotentialTransferSendersQueryVariables>;\nexport function refetchGetPotentialTransferSendersQuery(variables: GetPotentialTransferSendersQueryVariables) {\n      return { query: GetPotentialTransferSendersDocument, variables: variables };\n    }\nexport const List409aValuationsDocument: TypedDocumentNode<List409aValuationsQuery, List409aValuationsQueryVariables> = gql`\n  query list409aValuations($organisation: OrganisationCakeType!, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!) {\n  list409aValuations(\n    organisation: $organisation\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    pageData {\n      id\n      valuationDate\n      fairMarketValue\n      documentation {\n        id\n        name\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useList409aValuationsQuery__\n *\n * To run a query within a React component, call `useList409aValuationsQuery` and pass it any options that fit your needs.\n * When your component renders, `useList409aValuationsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useList409aValuationsQuery({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useList409aValuationsQuery(baseOptions: Apollo.QueryHookOptions<List409aValuationsQuery, List409aValuationsQueryVariables> & ({ variables: List409aValuationsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<List409aValuationsQuery, List409aValuationsQueryVariables>(List409aValuationsDocument, options);\n      }\nexport function useList409aValuationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<List409aValuationsQuery, List409aValuationsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<List409aValuationsQuery, List409aValuationsQueryVariables>(List409aValuationsDocument, options);\n        }\nexport function useList409aValuationsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<List409aValuationsQuery, List409aValuationsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<List409aValuationsQuery, List409aValuationsQueryVariables>(List409aValuationsDocument, options);\n        }\nexport type List409aValuationsQueryHookResult = ReturnType<typeof useList409aValuationsQuery>;\nexport type List409aValuationsLazyQueryHookResult = ReturnType<typeof useList409aValuationsLazyQuery>;\nexport type List409aValuationsSuspenseQueryHookResult = ReturnType<typeof useList409aValuationsSuspenseQuery>;\nexport type List409aValuationsQueryResult = Apollo.QueryResult<List409aValuationsQuery, List409aValuationsQueryVariables>;\nexport function refetchList409aValuationsQuery(variables: List409aValuationsQueryVariables) {\n      return { query: List409aValuationsDocument, variables: variables };\n    }\nexport const Get409aListDocument: TypedDocumentNode<Get409aListQuery, Get409aListQueryVariables> = gql`\n  query get409aList($organisationId: UUID!) {\n  organisation(organisationId: $organisationId) {\n    license {\n      oneOffAddons(filterAddon: VALUATION_409A) {\n        status\n        created\n        stripeId\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGet409aListQuery__\n *\n * To run a query within a React component, call `useGet409aListQuery` and pass it any options that fit your needs.\n * When your component renders, `useGet409aListQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGet409aListQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *   },\n * });\n */\nexport function useGet409aListQuery(baseOptions: Apollo.QueryHookOptions<Get409aListQuery, Get409aListQueryVariables> & ({ variables: Get409aListQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<Get409aListQuery, Get409aListQueryVariables>(Get409aListDocument, options);\n      }\nexport function useGet409aListLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<Get409aListQuery, Get409aListQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<Get409aListQuery, Get409aListQueryVariables>(Get409aListDocument, options);\n        }\nexport function useGet409aListSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<Get409aListQuery, Get409aListQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<Get409aListQuery, Get409aListQueryVariables>(Get409aListDocument, options);\n        }\nexport type Get409aListQueryHookResult = ReturnType<typeof useGet409aListQuery>;\nexport type Get409aListLazyQueryHookResult = ReturnType<typeof useGet409aListLazyQuery>;\nexport type Get409aListSuspenseQueryHookResult = ReturnType<typeof useGet409aListSuspenseQuery>;\nexport type Get409aListQueryResult = Apollo.QueryResult<Get409aListQuery, Get409aListQueryVariables>;\nexport function refetchGet409aListQuery(variables: Get409aListQueryVariables) {\n      return { query: Get409aListDocument, variables: variables };\n    }\nexport const AddHistorical409ADocument: TypedDocumentNode<AddHistorical409AMutation, AddHistorical409AMutationVariables> = gql`\n  mutation addHistorical409A($organisation: OrganisationCakeType!, $valuationDate: Date!, $fairMarketValue: CakeDecimal!, $documentation: DocumentCakeType, $applyExercisePrice: Boolean!) {\n  addHistorical409A(\n    organisation: $organisation\n    valuationDate: $valuationDate\n    documentation: $documentation\n    fairMarketValue: $fairMarketValue\n    applyExercisePrice: $applyExercisePrice\n  )\n}\n    `;\nexport type AddHistorical409AMutationFn = Apollo.MutationFunction<AddHistorical409AMutation, AddHistorical409AMutationVariables>;\n\n/**\n * __useAddHistorical409AMutation__\n *\n * To run a mutation, you first call `useAddHistorical409AMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useAddHistorical409AMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [addHistorical409AMutation, { data, loading, error }] = useAddHistorical409AMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      valuationDate: // value for 'valuationDate'\n *      fairMarketValue: // value for 'fairMarketValue'\n *      documentation: // value for 'documentation'\n *      applyExercisePrice: // value for 'applyExercisePrice'\n *   },\n * });\n */\nexport function useAddHistorical409AMutation(baseOptions?: Apollo.MutationHookOptions<AddHistorical409AMutation, AddHistorical409AMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<AddHistorical409AMutation, AddHistorical409AMutationVariables>(AddHistorical409ADocument, options);\n      }\nexport type AddHistorical409AMutationHookResult = ReturnType<typeof useAddHistorical409AMutation>;\nexport type AddHistorical409AMutationResult = Apollo.MutationResult<AddHistorical409AMutation>;\nexport type AddHistorical409AMutationOptions = Apollo.BaseMutationOptions<AddHistorical409AMutation, AddHistorical409AMutationVariables>;\nexport const DeleteHistorical409ADocument: TypedDocumentNode<DeleteHistorical409AMutation, DeleteHistorical409AMutationVariables> = gql`\n  mutation deleteHistorical409A($historical409A: Historical409ACakeType!, $removeDocumentation: Boolean!) {\n  deleteHistorical409A(\n    historical409A: $historical409A\n    removeDocumentation: $removeDocumentation\n  )\n}\n    `;\nexport type DeleteHistorical409AMutationFn = Apollo.MutationFunction<DeleteHistorical409AMutation, DeleteHistorical409AMutationVariables>;\n\n/**\n * __useDeleteHistorical409AMutation__\n *\n * To run a mutation, you first call `useDeleteHistorical409AMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteHistorical409AMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteHistorical409AMutation, { data, loading, error }] = useDeleteHistorical409AMutation({\n *   variables: {\n *      historical409A: // value for 'historical409A'\n *      removeDocumentation: // value for 'removeDocumentation'\n *   },\n * });\n */\nexport function useDeleteHistorical409AMutation(baseOptions?: Apollo.MutationHookOptions<DeleteHistorical409AMutation, DeleteHistorical409AMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteHistorical409AMutation, DeleteHistorical409AMutationVariables>(DeleteHistorical409ADocument, options);\n      }\nexport type DeleteHistorical409AMutationHookResult = ReturnType<typeof useDeleteHistorical409AMutation>;\nexport type DeleteHistorical409AMutationResult = Apollo.MutationResult<DeleteHistorical409AMutation>;\nexport type DeleteHistorical409AMutationOptions = Apollo.BaseMutationOptions<DeleteHistorical409AMutation, DeleteHistorical409AMutationVariables>;\nexport const ApplyHistorical409aStrikePriceDocument: TypedDocumentNode<ApplyHistorical409aStrikePriceMutation, ApplyHistorical409aStrikePriceMutationVariables> = gql`\n  mutation applyHistorical409aStrikePrice($historical409a: Historical409ACakeType!, $esop: EsopCakeType!) {\n  applyHistorical409aStrikePrice(historical409a: $historical409a, esop: $esop)\n}\n    `;\nexport type ApplyHistorical409aStrikePriceMutationFn = Apollo.MutationFunction<ApplyHistorical409aStrikePriceMutation, ApplyHistorical409aStrikePriceMutationVariables>;\n\n/**\n * __useApplyHistorical409aStrikePriceMutation__\n *\n * To run a mutation, you first call `useApplyHistorical409aStrikePriceMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useApplyHistorical409aStrikePriceMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [applyHistorical409aStrikePriceMutation, { data, loading, error }] = useApplyHistorical409aStrikePriceMutation({\n *   variables: {\n *      historical409a: // value for 'historical409a'\n *      esop: // value for 'esop'\n *   },\n * });\n */\nexport function useApplyHistorical409aStrikePriceMutation(baseOptions?: Apollo.MutationHookOptions<ApplyHistorical409aStrikePriceMutation, ApplyHistorical409aStrikePriceMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<ApplyHistorical409aStrikePriceMutation, ApplyHistorical409aStrikePriceMutationVariables>(ApplyHistorical409aStrikePriceDocument, options);\n      }\nexport type ApplyHistorical409aStrikePriceMutationHookResult = ReturnType<typeof useApplyHistorical409aStrikePriceMutation>;\nexport type ApplyHistorical409aStrikePriceMutationResult = Apollo.MutationResult<ApplyHistorical409aStrikePriceMutation>;\nexport type ApplyHistorical409aStrikePriceMutationOptions = Apollo.BaseMutationOptions<ApplyHistorical409aStrikePriceMutation, ApplyHistorical409aStrikePriceMutationVariables>;\nexport const GetVestingScheduleTemplatesDocument: TypedDocumentNode<GetVestingScheduleTemplatesQuery, GetVestingScheduleTemplatesQueryVariables> = gql`\n  query getVestingScheduleTemplates($organisationId: OrganisationCakeType!, $page: PositiveIntegerOrZero, $itemsPerPage: PositiveInteger) {\n  vestingScheduleTemplates(\n    organisation: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    pageData {\n      id\n      name\n      created\n      modified\n      vestingEvents {\n        vestingValuePercentage\n        eventType\n        vestingData {\n          duration {\n            value\n            granularity\n          }\n          frequency {\n            value\n            granularity\n          }\n          description\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetVestingScheduleTemplatesQuery__\n *\n * To run a query within a React component, call `useGetVestingScheduleTemplatesQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetVestingScheduleTemplatesQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetVestingScheduleTemplatesQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetVestingScheduleTemplatesQuery(baseOptions: Apollo.QueryHookOptions<GetVestingScheduleTemplatesQuery, GetVestingScheduleTemplatesQueryVariables> & ({ variables: GetVestingScheduleTemplatesQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetVestingScheduleTemplatesQuery, GetVestingScheduleTemplatesQueryVariables>(GetVestingScheduleTemplatesDocument, options);\n      }\nexport function useGetVestingScheduleTemplatesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetVestingScheduleTemplatesQuery, GetVestingScheduleTemplatesQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetVestingScheduleTemplatesQuery, GetVestingScheduleTemplatesQueryVariables>(GetVestingScheduleTemplatesDocument, options);\n        }\nexport function useGetVestingScheduleTemplatesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetVestingScheduleTemplatesQuery, GetVestingScheduleTemplatesQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetVestingScheduleTemplatesQuery, GetVestingScheduleTemplatesQueryVariables>(GetVestingScheduleTemplatesDocument, options);\n        }\nexport type GetVestingScheduleTemplatesQueryHookResult = ReturnType<typeof useGetVestingScheduleTemplatesQuery>;\nexport type GetVestingScheduleTemplatesLazyQueryHookResult = ReturnType<typeof useGetVestingScheduleTemplatesLazyQuery>;\nexport type GetVestingScheduleTemplatesSuspenseQueryHookResult = ReturnType<typeof useGetVestingScheduleTemplatesSuspenseQuery>;\nexport type GetVestingScheduleTemplatesQueryResult = Apollo.QueryResult<GetVestingScheduleTemplatesQuery, GetVestingScheduleTemplatesQueryVariables>;\nexport function refetchGetVestingScheduleTemplatesQuery(variables: GetVestingScheduleTemplatesQueryVariables) {\n      return { query: GetVestingScheduleTemplatesDocument, variables: variables };\n    }\nexport const CreateVestingScheduleTemplateDocument: TypedDocumentNode<CreateVestingScheduleTemplateMutation, CreateVestingScheduleTemplateMutationVariables> = gql`\n  mutation createVestingScheduleTemplate($organisation: OrganisationCakeType!, $name: CleanString!, $vestingScheduleTemplate: VestingScheduleTemplateInputType!) {\n  createVestingScheduleTemplate(\n    organisation: $organisation\n    name: $name\n    vestingScheduleTemplate: $vestingScheduleTemplate\n  )\n}\n    `;\nexport type CreateVestingScheduleTemplateMutationFn = Apollo.MutationFunction<CreateVestingScheduleTemplateMutation, CreateVestingScheduleTemplateMutationVariables>;\n\n/**\n * __useCreateVestingScheduleTemplateMutation__\n *\n * To run a mutation, you first call `useCreateVestingScheduleTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useCreateVestingScheduleTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [createVestingScheduleTemplateMutation, { data, loading, error }] = useCreateVestingScheduleTemplateMutation({\n *   variables: {\n *      organisation: // value for 'organisation'\n *      name: // value for 'name'\n *      vestingScheduleTemplate: // value for 'vestingScheduleTemplate'\n *   },\n * });\n */\nexport function useCreateVestingScheduleTemplateMutation(baseOptions?: Apollo.MutationHookOptions<CreateVestingScheduleTemplateMutation, CreateVestingScheduleTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<CreateVestingScheduleTemplateMutation, CreateVestingScheduleTemplateMutationVariables>(CreateVestingScheduleTemplateDocument, options);\n      }\nexport type CreateVestingScheduleTemplateMutationHookResult = ReturnType<typeof useCreateVestingScheduleTemplateMutation>;\nexport type CreateVestingScheduleTemplateMutationResult = Apollo.MutationResult<CreateVestingScheduleTemplateMutation>;\nexport type CreateVestingScheduleTemplateMutationOptions = Apollo.BaseMutationOptions<CreateVestingScheduleTemplateMutation, CreateVestingScheduleTemplateMutationVariables>;\nexport const EditVestingScheduleTemplateDocument: TypedDocumentNode<EditVestingScheduleTemplateMutation, EditVestingScheduleTemplateMutationVariables> = gql`\n  mutation editVestingScheduleTemplate($template: VestingScheduleTemplateCakeType!, $name: CleanString!, $vestingScheduleTemplate: VestingScheduleTemplateInputType!) {\n  editVestingScheduleTemplate(\n    template: $template\n    name: $name\n    vestingScheduleTemplate: $vestingScheduleTemplate\n  )\n}\n    `;\nexport type EditVestingScheduleTemplateMutationFn = Apollo.MutationFunction<EditVestingScheduleTemplateMutation, EditVestingScheduleTemplateMutationVariables>;\n\n/**\n * __useEditVestingScheduleTemplateMutation__\n *\n * To run a mutation, you first call `useEditVestingScheduleTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useEditVestingScheduleTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [editVestingScheduleTemplateMutation, { data, loading, error }] = useEditVestingScheduleTemplateMutation({\n *   variables: {\n *      template: // value for 'template'\n *      name: // value for 'name'\n *      vestingScheduleTemplate: // value for 'vestingScheduleTemplate'\n *   },\n * });\n */\nexport function useEditVestingScheduleTemplateMutation(baseOptions?: Apollo.MutationHookOptions<EditVestingScheduleTemplateMutation, EditVestingScheduleTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<EditVestingScheduleTemplateMutation, EditVestingScheduleTemplateMutationVariables>(EditVestingScheduleTemplateDocument, options);\n      }\nexport type EditVestingScheduleTemplateMutationHookResult = ReturnType<typeof useEditVestingScheduleTemplateMutation>;\nexport type EditVestingScheduleTemplateMutationResult = Apollo.MutationResult<EditVestingScheduleTemplateMutation>;\nexport type EditVestingScheduleTemplateMutationOptions = Apollo.BaseMutationOptions<EditVestingScheduleTemplateMutation, EditVestingScheduleTemplateMutationVariables>;\nexport const DeleteVestingScheduleTemplateDocument: TypedDocumentNode<DeleteVestingScheduleTemplateMutation, DeleteVestingScheduleTemplateMutationVariables> = gql`\n  mutation deleteVestingScheduleTemplate($vestingScheduleTemplate: VestingScheduleTemplateCakeType!) {\n  deleteVestingScheduleTemplate(vestingScheduleTemplate: $vestingScheduleTemplate)\n}\n    `;\nexport type DeleteVestingScheduleTemplateMutationFn = Apollo.MutationFunction<DeleteVestingScheduleTemplateMutation, DeleteVestingScheduleTemplateMutationVariables>;\n\n/**\n * __useDeleteVestingScheduleTemplateMutation__\n *\n * To run a mutation, you first call `useDeleteVestingScheduleTemplateMutation` within a React component and pass it any options that fit your needs.\n * When your component renders, `useDeleteVestingScheduleTemplateMutation` returns a tuple that includes:\n * - A mutate function that you can call at any time to execute the mutation\n * - An object with fields that represent the current status of the mutation's execution\n *\n * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;\n *\n * @example\n * const [deleteVestingScheduleTemplateMutation, { data, loading, error }] = useDeleteVestingScheduleTemplateMutation({\n *   variables: {\n *      vestingScheduleTemplate: // value for 'vestingScheduleTemplate'\n *   },\n * });\n */\nexport function useDeleteVestingScheduleTemplateMutation(baseOptions?: Apollo.MutationHookOptions<DeleteVestingScheduleTemplateMutation, DeleteVestingScheduleTemplateMutationVariables>) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useMutation<DeleteVestingScheduleTemplateMutation, DeleteVestingScheduleTemplateMutationVariables>(DeleteVestingScheduleTemplateDocument, options);\n      }\nexport type DeleteVestingScheduleTemplateMutationHookResult = ReturnType<typeof useDeleteVestingScheduleTemplateMutation>;\nexport type DeleteVestingScheduleTemplateMutationResult = Apollo.MutationResult<DeleteVestingScheduleTemplateMutation>;\nexport type DeleteVestingScheduleTemplateMutationOptions = Apollo.BaseMutationOptions<DeleteVestingScheduleTemplateMutation, DeleteVestingScheduleTemplateMutationVariables>;\nexport const GetDigestedPlanTransactionsDocument: TypedDocumentNode<GetDigestedPlanTransactionsQuery, GetDigestedPlanTransactionsQueryVariables> = gql`\n  query getDigestedPlanTransactions($planType: VestingPlanType!, $organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  digestedPlanTransactions(\n    planType: $planType\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    count\n    currentPage\n    pageData {\n      transactionDate\n      planName\n      transactionType\n      sharetype {\n        symbol\n      }\n      shareholder {\n        id\n        displayName\n        secondaryName\n        avatar\n        recipient {\n          id\n          displayName\n        }\n        trust {\n          id\n        }\n        investorData {\n          name\n          companyData {\n            identifierType\n          }\n        }\n      }\n      vestingValue\n      exercisePrice\n      transactionId\n      lastComment\n      attachedDocumentId\n      attachedDocumentName\n    }\n  }\n}\n    `;\n\n/**\n * __useGetDigestedPlanTransactionsQuery__\n *\n * To run a query within a React component, call `useGetDigestedPlanTransactionsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetDigestedPlanTransactionsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetDigestedPlanTransactionsQuery({\n *   variables: {\n *      planType: // value for 'planType'\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetDigestedPlanTransactionsQuery(baseOptions: Apollo.QueryHookOptions<GetDigestedPlanTransactionsQuery, GetDigestedPlanTransactionsQueryVariables> & ({ variables: GetDigestedPlanTransactionsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetDigestedPlanTransactionsQuery, GetDigestedPlanTransactionsQueryVariables>(GetDigestedPlanTransactionsDocument, options);\n      }\nexport function useGetDigestedPlanTransactionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetDigestedPlanTransactionsQuery, GetDigestedPlanTransactionsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetDigestedPlanTransactionsQuery, GetDigestedPlanTransactionsQueryVariables>(GetDigestedPlanTransactionsDocument, options);\n        }\nexport function useGetDigestedPlanTransactionsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetDigestedPlanTransactionsQuery, GetDigestedPlanTransactionsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetDigestedPlanTransactionsQuery, GetDigestedPlanTransactionsQueryVariables>(GetDigestedPlanTransactionsDocument, options);\n        }\nexport type GetDigestedPlanTransactionsQueryHookResult = ReturnType<typeof useGetDigestedPlanTransactionsQuery>;\nexport type GetDigestedPlanTransactionsLazyQueryHookResult = ReturnType<typeof useGetDigestedPlanTransactionsLazyQuery>;\nexport type GetDigestedPlanTransactionsSuspenseQueryHookResult = ReturnType<typeof useGetDigestedPlanTransactionsSuspenseQuery>;\nexport type GetDigestedPlanTransactionsQueryResult = Apollo.QueryResult<GetDigestedPlanTransactionsQuery, GetDigestedPlanTransactionsQueryVariables>;\nexport function refetchGetDigestedPlanTransactionsQuery(variables: GetDigestedPlanTransactionsQueryVariables) {\n      return { query: GetDigestedPlanTransactionsDocument, variables: variables };\n    }\nexport const GetPlanOffersWarrantsDocument: TypedDocumentNode<GetPlanOffersWarrantsQuery, GetPlanOffersWarrantsQueryVariables> = gql`\n  query getPlanOffersWarrants($organisationId: UUID!, $filterId: UUID, $page: PositiveInteger!, $itemsPerPage: PositiveInteger!, $filters: [ListFilterType!], $sort: [CleanString!], $search: String) {\n  offers: warrantPlanOffers(\n    organisationId: $organisationId\n    filterId: $filterId\n    page: $page\n    itemsPerPage: $itemsPerPage\n    filters: $filters\n    sort: $sort\n    search: $search\n  ) {\n    plan {\n      id\n      vestingValue\n      totalOffered\n      totalLapsed\n      organisation {\n        fullyDilutedShares\n      }\n    }\n    count\n    currentPage\n    notSignedUpCount\n    shareholderCount\n    pageData {\n      id\n      modified\n      groupId\n      planId\n      offerLetterId\n      dateGranted\n      grantDateDefault\n      vestStartDate\n      emailsOn\n      requireWitness\n      shareholderId\n      shareholderDisplayName\n      shareholderSecondaryName\n      shareholderAvatar\n      shareholderHasLoggedIn\n      shareholderConsideredInvited\n      shEmail\n      stakeholderType: shareholderType\n      isTrust: shareholderIsTrust\n      status\n      softStatus\n      country\n      vestingValue\n      availableToLapse\n      availableToExercise\n      availableToVest\n      vested\n      granted\n      lapsed\n      exercised\n      hasOngoingPauseEvents\n      hasScheduledPauseEvents\n    }\n  }\n}\n    `;\n\n/**\n * __useGetPlanOffersWarrantsQuery__\n *\n * To run a query within a React component, call `useGetPlanOffersWarrantsQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanOffersWarrantsQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanOffersWarrantsQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      filterId: // value for 'filterId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *      filters: // value for 'filters'\n *      sort: // value for 'sort'\n *      search: // value for 'search'\n *   },\n * });\n */\nexport function useGetPlanOffersWarrantsQuery(baseOptions: Apollo.QueryHookOptions<GetPlanOffersWarrantsQuery, GetPlanOffersWarrantsQueryVariables> & ({ variables: GetPlanOffersWarrantsQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanOffersWarrantsQuery, GetPlanOffersWarrantsQueryVariables>(GetPlanOffersWarrantsDocument, options);\n      }\nexport function useGetPlanOffersWarrantsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanOffersWarrantsQuery, GetPlanOffersWarrantsQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanOffersWarrantsQuery, GetPlanOffersWarrantsQueryVariables>(GetPlanOffersWarrantsDocument, options);\n        }\nexport function useGetPlanOffersWarrantsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanOffersWarrantsQuery, GetPlanOffersWarrantsQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanOffersWarrantsQuery, GetPlanOffersWarrantsQueryVariables>(GetPlanOffersWarrantsDocument, options);\n        }\nexport type GetPlanOffersWarrantsQueryHookResult = ReturnType<typeof useGetPlanOffersWarrantsQuery>;\nexport type GetPlanOffersWarrantsLazyQueryHookResult = ReturnType<typeof useGetPlanOffersWarrantsLazyQuery>;\nexport type GetPlanOffersWarrantsSuspenseQueryHookResult = ReturnType<typeof useGetPlanOffersWarrantsSuspenseQuery>;\nexport type GetPlanOffersWarrantsQueryResult = Apollo.QueryResult<GetPlanOffersWarrantsQuery, GetPlanOffersWarrantsQueryVariables>;\nexport function refetchGetPlanOffersWarrantsQuery(variables: GetPlanOffersWarrantsQueryVariables) {\n      return { query: GetPlanOffersWarrantsDocument, variables: variables };\n    }\nexport const GetPlanNamesWarrantDocument: TypedDocumentNode<GetPlanNamesWarrantQuery, GetPlanNamesWarrantQueryVariables> = gql`\n  query getPlanNamesWarrant($organisationId: UUID!, $page: Int, $itemsPerPage: Int) {\n  warrants(\n    organisationId: $organisationId\n    page: $page\n    itemsPerPage: $itemsPerPage\n  ) {\n    id\n    name\n  }\n}\n    `;\n\n/**\n * __useGetPlanNamesWarrantQuery__\n *\n * To run a query within a React component, call `useGetPlanNamesWarrantQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetPlanNamesWarrantQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetPlanNamesWarrantQuery({\n *   variables: {\n *      organisationId: // value for 'organisationId'\n *      page: // value for 'page'\n *      itemsPerPage: // value for 'itemsPerPage'\n *   },\n * });\n */\nexport function useGetPlanNamesWarrantQuery(baseOptions: Apollo.QueryHookOptions<GetPlanNamesWarrantQuery, GetPlanNamesWarrantQueryVariables> & ({ variables: GetPlanNamesWarrantQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetPlanNamesWarrantQuery, GetPlanNamesWarrantQueryVariables>(GetPlanNamesWarrantDocument, options);\n      }\nexport function useGetPlanNamesWarrantLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetPlanNamesWarrantQuery, GetPlanNamesWarrantQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetPlanNamesWarrantQuery, GetPlanNamesWarrantQueryVariables>(GetPlanNamesWarrantDocument, options);\n        }\nexport function useGetPlanNamesWarrantSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetPlanNamesWarrantQuery, GetPlanNamesWarrantQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetPlanNamesWarrantQuery, GetPlanNamesWarrantQueryVariables>(GetPlanNamesWarrantDocument, options);\n        }\nexport type GetPlanNamesWarrantQueryHookResult = ReturnType<typeof useGetPlanNamesWarrantQuery>;\nexport type GetPlanNamesWarrantLazyQueryHookResult = ReturnType<typeof useGetPlanNamesWarrantLazyQuery>;\nexport type GetPlanNamesWarrantSuspenseQueryHookResult = ReturnType<typeof useGetPlanNamesWarrantSuspenseQuery>;\nexport type GetPlanNamesWarrantQueryResult = Apollo.QueryResult<GetPlanNamesWarrantQuery, GetPlanNamesWarrantQueryVariables>;\nexport function refetchGetPlanNamesWarrantQuery(variables: GetPlanNamesWarrantQueryVariables) {\n      return { query: GetPlanNamesWarrantDocument, variables: variables };\n    }\nexport const GetExerciseDataWarrantDocument: TypedDocumentNode<GetExerciseDataWarrantQuery, GetExerciseDataWarrantQueryVariables> = gql`\n  query getExerciseDataWARRANT($offer: WarrantOfferCakeType!) {\n  investorHoldings: investorWarrantHoldings(offer: $offer) {\n    availableToExercise\n    availableToLapse\n    availableToVestMilestone\n    exercised\n    offer {\n      id\n      currency\n      exercisePrice\n      shareholder {\n        id\n        displayName\n        avatar\n        organisation {\n          lastCertificateNumber\n        }\n      }\n    }\n  }\n}\n    `;\n\n/**\n * __useGetExerciseDataWarrantQuery__\n *\n * To run a query within a React component, call `useGetExerciseDataWarrantQuery` and pass it any options that fit your needs.\n * When your component renders, `useGetExerciseDataWarrantQuery` returns an object from Apollo Client that contains loading, error, and data properties\n * you can use to render your UI.\n *\n * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;\n *\n * @example\n * const { data, loading, error } = useGetExerciseDataWarrantQuery({\n *   variables: {\n *      offer: // value for 'offer'\n *   },\n * });\n */\nexport function useGetExerciseDataWarrantQuery(baseOptions: Apollo.QueryHookOptions<GetExerciseDataWarrantQuery, GetExerciseDataWarrantQueryVariables> & ({ variables: GetExerciseDataWarrantQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {\n        const options = {...defaultOptions, ...baseOptions};\n        return Apollo.useQuery<GetExerciseDataWarrantQuery, GetExerciseDataWarrantQueryVariables>(GetExerciseDataWarrantDocument, options);\n      }\nexport function useGetExerciseDataWarrantLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<GetExerciseDataWarrantQuery, GetExerciseDataWarrantQueryVariables>) {\n          const options = {...defaultOptions, ...baseOptions};\n          return Apollo.useLazyQuery<GetExerciseDataWarrantQuery, GetExerciseDataWarrantQueryVariables>(GetExerciseDataWarrantDocument, options);\n        }\nexport function useGetExerciseDataWarrantSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<GetExerciseDataWarrantQuery, GetExerciseDataWarrantQueryVariables>) {\n          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions};\n          return Apollo.useSuspenseQuery<GetExerciseDataWarrantQuery, GetExerciseDataWarrantQueryVariables>(GetExerciseDataWarrantDocument, options);\n        }\nexport type GetExerciseDataWarrantQueryHookResult = ReturnType<typeof useGetExerciseDataWarrantQuery>;\nexport type GetExerciseDataWarrantLazyQueryHookResult = ReturnType<typeof useGetExerciseDataWarrantLazyQuery>;\nexport type GetExerciseDataWarrantSuspenseQueryHookResult = ReturnType<typeof useGetExerciseDataWarrantSuspenseQuery>;\nexport type GetExerciseDataWarrantQueryResult = Apollo.QueryResult<GetExerciseDataWarrantQuery, GetExerciseDataWarrantQueryVariables>;\nexport function refetchGetExerciseDataWarrantQuery(variables: GetExerciseDataWarrantQueryVariables) {\n      return { query: GetExerciseDataWarrantDocument, variables: variables };\n    }","import { AppContext, getAppContext } from \"@base/core/CakeStore\";\nimport { useOrgStore } from \"@base/hooks/useOrgStore\";\n\n/**\n * Generates a discriminated union for events that have specific required properties.\n *\n * @template TTrackEvent - The complete string literal union of all possible event names.\n * @template TEventPropsMap - An object mapping specific event names (keys) to their required properties (values).\n * We use `Partial<Record<TTrackEvent, object>>` to ensure the keys of\n * TEventPropsMap are a subset of TTrackEvent.\n */\ntype TEventsWithRequiredProps<\n\tTTrackEvent extends string,\n\tTEventPropsMap extends Partial<Record<TTrackEvent, object>>\n> = {\n\t// Iterate over only the keys present in TEventPropsMap.\n\t// This ensures that if TEventPropsMap is empty, this type resolves to 'never'.\n\t[K in keyof TEventPropsMap]: __BaseEvent__ & { event: K } & TEventPropsMap[K];\n}[keyof TEventPropsMap];\n\n/**\n * Defines the shape for all common events that do NOT have specific required properties.\n *\n * @template TTrackEvent - The complete string literal union of all possible event names.\n * @template TEventPropsMap - An object mapping specific event names to their required properties.\n */\ninterface TCommonEvent<TTrackEvent extends string, TEventPropsMap extends Partial<Record<TTrackEvent, object>>>\n\textends __BaseEvent__ {\n\t// The event name is any event from TTrackEvent *except* for those\n\t// defined as keys in TEventPropsMap.\n\tevent: Exclude<TTrackEvent, keyof TEventPropsMap>;\n}\n\n/**\n * Creates the final, comprehensive analytics event type.\n * This is a union of:\n * 1. All common events (those without specific required props).\n * 2. All special events (those with specific required props).\n *\n * @template TTrackEvent - The complete string literal union of all possible event names.\n * @template TEventPropsMap - An object mapping specific event names to their required properties.\n *\n * @example\n * type MyEvents = \"doc_download\" | \"message_react\" | \"open_external_link\";\n * type MyPropsMap = {\n * open_external_link: { link: string };\n * };\n *\n * type FinalAnalyticsEvent = TAnalyticsEvent<MyEvents, MyPropsMap>;\n *\n * // This would be valid:\n * // { event: \"doc_download\" }\n * // { event: \"message_react\" }\n * // { event: \"open_external_link\", link: \"https://example.com\" }\n *\n * // This would be invalid:\n * // { event: \"open_external_link\" } // Missing required props\n */\ntype TAnalyticsEvent<TTrackEvent extends string, TEventPropsMap extends Partial<Record<TTrackEvent, object>>> =\n\t| TCommonEvent<TTrackEvent, TEventPropsMap>\n\t| TEventsWithRequiredProps<TTrackEvent, TEventPropsMap>;\n\ntype TrackEventStep = \"success\" | \"error\" | \"intent\" | \"attempt\";\n\n// Common event types that both platforms share\ntype BaseTrackEvent =\n\t| \"webapp_page_view\"\n\t| \"doc_download\"\n\t| \"account_logout\"\n\t| \"open_plain\"\n\t| \"open_external_link\"\n\t| \"offer_add_witness\"\n\t| \"exercise_request_action\"\n\t| \"people_columns\"\n\t| \"message_react\"\n\t| \"message_reply\"\n\t| \"terms_acceptance\";\n\n// Base event interface that can be extended by platform-specific types\ninterface __BaseEvent__ {\n\tevent: string; // Will be narrowed by platform-specific types\n\tevent_step: TrackEventStep;\n\ttarget_platform?: AppContext[\"APP_SEGMENT\"];\n\tcreated_at?: string;\n\treferrer?: string;\n\turl?: string;\n\ttarget?: string;\n\ttarget_child?: string;\n\ttarget_parent?: string;\n\torgid?: string; // if not supplied, it will be injected for the founder app\n\tcountry?: string; // if not supplied, it will be injected for the founder app\n}\n\ntype EventRequiredPropsMap = {\n\topen_external_link: {\n\t\tlink: string;\n\t};\n};\n\ntype BaseEventInternal = TAnalyticsEvent<BaseTrackEvent, EventRequiredPropsMap>;\n\n// UTM code extraction utility\nfunction extractUtmCodes(): Record<string, string | null> {\n\tconst searchParams = new URLSearchParams(window.location.search);\n\n\treturn {\n\t\tutm_source: searchParams.get(\"utm_source\"),\n\t\tutm_term: searchParams.get(\"utm_term\"),\n\t\tutm_medium: searchParams.get(\"utm_medium\"),\n\t\tutm_content: searchParams.get(\"utm_content\"),\n\t\tutm_campaign: searchParams.get(\"utm_campaign\"),\n\t\tutm_source_last: searchParams.get(\"utm_source_last\"),\n\t\tutm_term_last: searchParams.get(\"utm_term_last\"),\n\t\tutm_medium_last: searchParams.get(\"utm_medium_last\"),\n\t\tutm_content_last: searchParams.get(\"utm_content_last\"),\n\t\tutm_campaign_last: searchParams.get(\"utm_campaign_last\"),\n\t\tcta_platform: searchParams.get(\"cta_platform\"),\n\t\tcta_location: searchParams.get(\"cta_location\"),\n\t\tcta_button: searchParams.get(\"cta_button\"),\n\t};\n}\n\n// WebSocket management\nlet tracking_websocket: WebSocket | null = null;\n\nfunction getOrCreateWebSocket(): Promise<WebSocket> {\n\treturn new Promise((resolve, reject) => {\n\t\tif (\n\t\t\t!tracking_websocket ||\n\t\t\ttracking_websocket.readyState === 2 /* CLOSING */ ||\n\t\t\ttracking_websocket.readyState === 3 /* CLOSED */\n\t\t) {\n\t\t\ttracking_websocket = new WebSocket(\n\t\t\t\t`${window.location.protocol === \"http:\" ? \"ws\" : \"wss\"}://${window.location.host}/ws/tracking`\n\t\t\t);\n\t\t\ttracking_websocket.onerror = console.warn;\n\t\t\ttracking_websocket.onclose = console.warn;\n\t\t\ttracking_websocket.addEventListener(\"open\", () => resolve(tracking_websocket!));\n\t\t} else if (tracking_websocket.readyState === 0 /* CONNECTING */) {\n\t\t\ttracking_websocket.addEventListener(\"open\", () => resolve(tracking_websocket!));\n\t\t} else if (tracking_websocket.readyState === 1 /* OPEN */) {\n\t\t\tresolve(tracking_websocket);\n\t\t} else {\n\t\t\treject(\"El chupacabra haunts this code\");\n\t\t}\n\t});\n}\n\n// Base tracking function that can be extended by platform-specific implementations\nfunction baseCakeTrack<T extends __BaseEvent__>(event: T): Promise<void> {\n\tif (!event.event) {\n\t\tif (getAppContext()?.APP_ENVIRONMENT === \"local\") {\n\t\t\tconsole.trace([\"Missing event data\", event]);\n\t\t\talert(\"Bad analytics event, check console.\");\n\t\t} else {\n\t\t\tconsole.error(`Missing event data: ${event}`);\n\t\t}\n\t\treturn Promise.reject(\"Missing event data\");\n\t}\n\n\t// Extract UTM codes for page view events\n\tconst utm_codes = event.event === \"webapp_page_view\" ? extractUtmCodes() : {};\n\n\tconst appContext = getAppContext();\n\tconst platform = appContext?.APP_SEGMENT || \"unknown\";\n\n\t// Build base event object\n\tlet enrichedEvent: __BaseEvent__ = {\n\t\tevent_step: \"success\" as const, //  just a default, to be overridden by cakeTrack calls when necessary\n\t\tcreated_at: new Date().toISOString(),\n\t\treferrer: document.referrer,\n\t\turl: window.location.href,\n\t\tsession_id: window.amplitude?.getSessionId() || null, // inject amplitude session id if available\n\t\ttarget_platform: platform, // inject platform\n\t\t...event,\n\t\t...utm_codes,\n\t};\n\n\t// const platformData = platformEnhancer(event);\n\tif (platform === \"founder\") {\n\t\tenrichedEvent = {\n\t\t\t...enrichedEvent,\n\t\t\torgid: event.orgid || useOrgStore.getState().selectedOrgId || \"\",\n\t\t\tcountry: event.country || useOrgStore.getState().organisationData?.country || \"\",\n\t\t};\n\t}\n\n\tif (window[\"showEvents\"]) {\n\t\tconsole.log(\" event:\", enrichedEvent.event, \"\\n\", \"event_step:\", enrichedEvent.event_step, \"\\n\", {\n\t\t\tdata: enrichedEvent,\n\t\t});\n\t}\n\n\treturn getOrCreateWebSocket()\n\t\t.then((ws: WebSocket) => {\n\t\t\tws.send(JSON.stringify(enrichedEvent));\n\t\t})\n\t\t.catch(console.warn);\n}\n\nexport {\n\tbaseCakeTrack as __baseCakeTrackInternal__,\n\ttype BaseEventInternal as __BaseEventInternal__,\n\ttype BaseTrackEvent as __BaseTrackEvent__,\n\ttype TrackEventStep as __TrackEventStep__,\n\ttype TAnalyticsEvent,\n};\n","import { useOrgStore } from \"@base/hooks/useOrgStore\";\nimport i18n from \"i18next\";\nimport au from \"./locales/en.au.json\";\nimport gb from \"./locales/en.gb.json\";\nimport llc from \"./locales/en.llc.json\";\nimport us from \"./locales/en.us.json\";\n\nconst resources = {\n\ten: { llc, us, au, gb },\n};\n\nexport function initCakeI18n() {\n\ti18n.init({\n\t\tresources,\n\t\tlng: \"en\",\n\t\tdefaultNS: \"au\",\n\t\tdebug: false,\n\t});\n}\n\nexport function translate<T>(text: T) {\n\tconst orgData = useOrgStore.getState().organisationData;\n\tconst nameSpace = orgData?.type === \"LLC\" ? \"llc\" : orgData?.country?.toLocaleLowerCase?.() ?? \"\";\n\treturn i18n.t(text as string, { ns: nameSpace }) as T;\n}\n","import { Button } from \"@base/components/common/primitives\";\nimport { DynamicIcons } from \"@base/utils/images\";\nimport { normalizeProps, useMachine } from \"@zag-js/react\";\nimport * as toast from \"@zag-js/toast\";\nimport React, { useId, useMemo } from \"react\";\nimport styles from \"./Toast.module.scss\";\nimport DOMPurify from \"dompurify\";\n\nconst TOAST_DEFAULT_DURATION = 4000;\n\nconst toaster = toast.createStore({\n\toverlap: false,\n\tplacement: \"bottom-start\",\n});\n\ntype ToastProps = {\n\ttoastProps: toast.Props;\n\tparentService: toast.GroupService;\n};\n\nconst Toast = ({ toastProps, parentService }: ToastProps) => {\n\tconst service = useMachine(toast.machine, {\n\t\t...toastProps,\n\t\tparent: parentService,\n\t});\n\tconst api = toast.connect(service, normalizeProps);\n\n\t// inner HTML needs to be memoized to avoid XSS issues and unnecessary re-renders\n\tconst memoizedInnerHtml = useMemo(() => {\n\t\tconst config = {\n\t\t\tALLOWED_TAGS: [\"b\", \"i\", \"br\", \"strong\", \"small\", \"big\"],\n\t\t\tALLOWED_ATTR: [],\n\t\t};\n\t\tconst sanitizedHTML = DOMPurify.sanitize(api.description, config);\n\t\treturn { __html: sanitizedHTML };\n\t}, [api.description]);\n\n\treturn (\n\t\t<div className={styles.toastContainer} {...api.getRootProps()} data-test=\"toast-container\">\n\t\t\t<div {...api.getGhostBeforeProps()} />\n\t\t\t<p {...api.getDescriptionProps()} dangerouslySetInnerHTML={memoizedInnerHtml}></p>\n\t\t\t<Button\n\t\t\t\tdata-test=\"toast-dismiss-button\"\n\t\t\t\ticon={DynamicIcons.close}\n\t\t\t\tvariant=\"tertiary\"\n\t\t\t\tsize=\"small\"\n\t\t\t\tonClick={api.dismiss}\n\t\t\t/>\n\n\t\t\t<div {...api.getGhostAfterProps()} />\n\t\t</div>\n\t);\n};\n\nconst Toaster = () => {\n\tconst service = useMachine(toast.group.machine, {\n\t\tid: useId(),\n\t\tstore: toaster,\n\t});\n\tconst api = toast.group.connect(service, normalizeProps);\n\treturn (\n\t\t<div {...api.getGroupProps()} className={styles.toastGroupHolder}>\n\t\t\t{api.getToasts().map((toastProps) => (\n\t\t\t\t<Toast key={toastProps.id} toastProps={toastProps} parentService={service} />\n\t\t\t))}\n\t\t</div>\n\t);\n};\n\nconst ToastDismiss = (id?: string) => {\n\tqueueMicrotask(() => {\n\t\ttoaster.dismiss(id);\n\t});\n};\n\nconst ToastError = (message: string, duration: number = TOAST_DEFAULT_DURATION) => {\n\tqueueMicrotask(() => {\n\t\ttoaster.create({\n\t\t\ttitle: null,\n\t\t\tdescription: message,\n\t\t\tduration,\n\t\t\ttype: \"error\",\n\t\t});\n\t});\n};\n\nconst ToastSuccess = (message: string, duration: number = TOAST_DEFAULT_DURATION) => {\n\tqueueMicrotask(() => {\n\t\ttoaster.create({\n\t\t\ttitle: null,\n\t\t\tdescription: message,\n\t\t\tduration,\n\t\t\ttype: \"success\",\n\t\t});\n\t});\n};\n\nconst ToastInfo = (message: string, duration: number = TOAST_DEFAULT_DURATION) => {\n\tqueueMicrotask(() => {\n\t\ttoaster.create({\n\t\t\ttitle: null,\n\t\t\tdescription: message,\n\t\t\tduration,\n\t\t\ttype: \"info\",\n\t\t});\n\t});\n};\n\nconst useToast = () => {\n\treturn { toaster, ToastDismiss, ToastError, ToastSuccess, ToastInfo };\n};\n\nexport { Toaster, useToast };\n","// extracted by mini-css-extract-plugin\nexport default {\"toastGroupHolder\":\"toastGroupHolder--Toast-module--NlLIo\",\"toastContainer\":\"toastContainer--Toast-module--CUvui\"};","export type DynamicIconsTypes = keyof typeof DynamicIcons;\n\n// Dynamic icons\nimport add from \"../assets/images/dynamic_icons/icon_add.svg\";\nimport addCircle from \"../assets/images/dynamic_icons/icon_add_circle.svg\";\nimport alarm from \"../assets/images/dynamic_icons/icon_alarm.svg\";\nimport alertDynamic from \"../assets/images/dynamic_icons/icon_alert.svg\";\nimport alertTriangle from \"../assets/images/dynamic_icons/icon_alert_triangle.svg\";\nimport arrow from \"../assets/images/dynamic_icons/icon_arrow.svg\";\nimport arrowCircle from \"../assets/images/dynamic_icons/icon_arrow_circle.svg\";\nimport arrowSort from \"../assets/images/dynamic_icons/icon_arrow_sort.svg\";\nimport arrowsTriangle from \"../assets/images/dynamic_icons/icon_arrows_triangle.svg\";\nimport attachment from \"../assets/images/dynamic_icons/icon_attachment.svg\";\nimport barLineChart from \"../assets/images/dynamic_icons/icon_bar_line_chart.svg\";\nimport cakeStroke from \"../assets/images/dynamic_icons/icon_cake_stroke.svg\";\nimport calculator from \"../assets/images/dynamic_icons/icon_calculator.svg\";\nimport caret from \"../assets/images/dynamic_icons/icon_caret.svg\";\nimport certificate from \"../assets/images/dynamic_icons/icon_certificate.svg\";\nimport chat from \"../assets/images/dynamic_icons/icon_chat.svg\";\nimport checkBg from \"../assets/images/dynamic_icons/icon_check_bg.svg\";\nimport checkmark from \"../assets/images/dynamic_icons/icon_checkmark.svg\";\nimport checkmarkCircle from \"../assets/images/dynamic_icons/icon_checkmark_circle.svg\";\nimport checkmarkDashedCircle from \"../assets/images/dynamic_icons/icon_checkmark_dashed_circle.svg\";\nimport chevron from \"../assets/images/dynamic_icons/icon_chevron.svg\";\nimport close from \"../assets/images/dynamic_icons/icon_close.svg\";\nimport closeCircle from \"../assets/images/dynamic_icons/icon_close_circle.svg\";\nimport columns from \"../assets/images/dynamic_icons/icon_columns.svg\";\nimport comment from \"../assets/images/dynamic_icons/icon_comment.svg\";\nimport commentActive from \"../assets/images/dynamic_icons/icon_comment_active.svg\";\nimport copy from \"../assets/images/dynamic_icons/icon_copy.svg\";\nimport copyPaste from \"../assets/images/dynamic_icons/icon_copy_paste.svg\";\nimport currencyDollar from \"../assets/images/dynamic_icons/icon_currency_dollar.svg\";\nimport date from \"../assets/images/dynamic_icons/icon_date.svg\";\nimport deleteIcon from \"../assets/images/dynamic_icons/icon_delete.svg\";\nimport document from \"../assets/images/dynamic_icons/icon_document.svg\";\nimport documentAdd from \"../assets/images/dynamic_icons/icon_document_add.svg\";\nimport documentAttachment from \"../assets/images/dynamic_icons/icon_document_attachment.svg\";\nimport documentCheckmark from \"../assets/images/dynamic_icons/icon_document_checkmark.svg\";\nimport done from \"../assets/images/dynamic_icons/icon_done.svg\";\nimport doneEggplant from \"../assets/images/dynamic_icons/icon_done_eggplant.svg\";\nimport doneGrey from \"../assets/images/dynamic_icons/icon_done_grey.svg\";\nimport download from \"../assets/images/dynamic_icons/icon_download.svg\";\nimport drag from \"../assets/images/dynamic_icons/icon_drag.svg\";\nimport envelope from \"../assets/images/dynamic_icons/icon_envelope.svg\";\nimport edit from \"../assets/images/dynamic_icons/icon_edit.svg\";\nimport editSquare from \"../assets/images/dynamic_icons/icon_edit_square.svg\";\nimport eyeSlash from \"../assets/images/dynamic_icons/icon_eye_slash.svg\";\nimport exercise from \"../assets/images/dynamic_icons/icon_exercise.svg\";\nimport fileArrowUp from \"../assets/images/dynamic_icons/icon_file_arrow_up.svg\";\nimport files from \"../assets/images/dynamic_icons/icon_files.svg\";\nimport filter from \"../assets/images/dynamic_icons/icon_filter.svg\";\nimport filterStatus from \"../assets/images/dynamic_icons/icon_filter_status.svg\";\nimport filters from \"../assets/images/dynamic_icons/icon_filters.svg\";\nimport flag from \"../assets/images/dynamic_icons/icon_flag.svg\";\nimport gear from \"../assets/images/dynamic_icons/icon_gear.svg\";\nimport grid from \"../assets/images/dynamic_icons/icon_grid.svg\";\nimport handsClapping from \"../assets/images/dynamic_icons/icon_hands_clapping.svg\";\nimport help from \"../assets/images/dynamic_icons/icon_help.svg\";\nimport info from \"../assets/images/dynamic_icons/icon_info.svg\";\nimport infoFill from \"../assets/images/dynamic_icons/icon_info_fill.svg\";\nimport lifeBuoy from \"../assets/images/dynamic_icons/icon_lifebuoy.svg\";\nimport lineChart from \"../assets/images/dynamic_icons/icon_line_chart.svg\";\nimport listMagnifyingGlass from \"../assets/images/dynamic_icons/icon_list_magnifying_glass.svg\";\nimport minusCircle from \"../assets/images/dynamic_icons/icon_minus_circle.svg\";\nimport more from \"../assets/images/dynamic_icons/icon_more.svg\";\nimport move from \"../assets/images/dynamic_icons/icon_move.svg\";\nimport notePencil from \"../assets/images/dynamic_icons/icon_note_pencil.svg\";\nimport notification from \"../assets/images/dynamic_icons/icon_notification.svg\";\nimport notificationAlert from \"../assets/images/dynamic_icons/icon_notification_alert.svg\";\nimport offline from \"../assets/images/dynamic_icons/icon_offline.svg\";\nimport pause from \"../assets/images/dynamic_icons/icon_pause.svg\";\nimport pen from \"../assets/images/dynamic_icons/icon_pen.svg\";\nimport pencil from \"../assets/images/dynamic_icons/icon_pencil.svg\";\nimport percentage from \"../assets/images/dynamic_icons/icon_percentage.svg\";\nimport pieChart from \"../assets/images/dynamic_icons/icon_pie_chart.svg\";\nimport play from \"../assets/images/dynamic_icons/icon_play.svg\";\nimport mapPin from \"@base/assets/images/dynamic_icons/icon_map_pin.svg\";\nimport filterFlag from \"@base/assets/images/dynamic_icons/icon_filter_flag.svg\";\nimport idBadge from \"@base/assets/images/dynamic_icons/icon_id_badge.svg\";\nimport phone from \"@base/assets/images/dynamic_icons/icon_phone.svg\";\nimport users from \"@base/assets/images/dynamic_icons/icon_users.svg\";\nimport presentation from \"../assets/images/dynamic_icons/icon_presentation.svg\";\nimport puzzle from \"../assets/images/dynamic_icons/icon_puzzle.svg\";\nimport refresh from \"../assets/images/dynamic_icons/icon_refresh.svg\";\nimport reminder from \"../assets/images/dynamic_icons/icon_reminder.svg\";\nimport reply from \"../assets/images/dynamic_icons/icon_reply.svg\";\nimport reset from \"../assets/images/dynamic_icons/icon_reset.svg\";\nimport resume from \"../assets/images/dynamic_icons/icon_resume.svg\";\nimport scribble from \"../assets/images/dynamic_icons/icon_scribble.svg\";\nimport search from \"../assets/images/dynamic_icons/icon_search.svg\";\nimport send from \"../assets/images/dynamic_icons/icon_send.svg\";\nimport settings from \"../assets/images/dynamic_icons/icon_settings.svg\";\nimport shield from \"../assets/images/dynamic_icons/icon_shield.svg\";\nimport square from \"../assets/images/dynamic_icons/icon_square.svg\";\nimport starOutline from \"../assets/images/dynamic_icons/icon_star_outline.svg\";\nimport table from \"../assets/images/dynamic_icons/icon_table.svg\";\nimport thumbs from \"../assets/images/dynamic_icons/icon_thumbs.svg\";\nimport time from \"../assets/images/dynamic_icons/icon_time.svg\";\nimport trendUp from \"../assets/images/dynamic_icons/icon_trend_up.svg\";\nimport user from \"../assets/images/dynamic_icons/icon_user.svg\";\nimport userDashed from \"../assets/images/dynamic_icons/icon_user_dashed.svg\";\nimport userMultiple from \"../assets/images/dynamic_icons/icon_user_multiple.svg\";\nimport usersAdd from \"../assets/images/dynamic_icons/icon_users_add.svg\";\nimport usersCheckmark from \"../assets/images/dynamic_icons/icon_users_checkmark.svg\";\nimport vest from \"../assets/images/dynamic_icons/icon_vest.svg\";\nimport vestStop from \"../assets/images/dynamic_icons/icon_vest_stop.svg\";\nimport tag from \"../assets/images/dynamic_icons/icon_tag.svg\";\nimport rocket from \"../assets/images/dynamic_icons/icon_rocket.svg\";\nimport downgrade from \"../assets/images/dynamic_icons/icon_downgrade.svg\";\nimport lock from \"../assets/images/dynamic_icons/icon_lock.svg\";\nimport save from \"../assets/images/dynamic_icons/icon_save.svg\";\nimport upload from \"../assets/images/dynamic_icons/icon_upload.svg\";\n\n// Icons Menu\nimport menuBoardApprovals from \"../assets/images/dynamic_icons/menu/icon_menu_board_approvals.svg\";\nimport menuCaptable from \"../assets/images/dynamic_icons/menu/icon_menu_captable.svg\";\nimport menuClipboard from \"../assets/images/dynamic_icons/menu/icon_menu_clipboard.svg\";\nimport menuClock from \"../assets/images/dynamic_icons/menu/icon_menu_clock.svg\";\nimport menuCommunication from \"../assets/images/dynamic_icons/menu/icon_menu_communication.svg\";\nimport menuDashboard from \"../assets/images/dynamic_icons/menu/icon_menu_dashboard.svg\";\nimport menuDocuments from \"../assets/images/dynamic_icons/menu/icon_menu_documents.svg\";\nimport menuEquity from \"../assets/images/dynamic_icons/menu/icon_menu_equity.svg\";\nimport menuInbox from \"../assets/images/dynamic_icons/menu/icon_menu_inbox.svg\";\nimport menuLiquidityInterest from \"../assets/images/dynamic_icons/menu/icon_menu_liquidity_interest.svg\";\nimport menuPeople from \"../assets/images/dynamic_icons/menu/icon_menu_people.svg\";\nimport menuQuickstart from \"../assets/images/dynamic_icons/menu/icon_menu_quickstart.svg\";\nimport menuSettings from \"../assets/images/dynamic_icons/menu/icon_menu_settings.svg\";\nimport menuSupportAdmin from \"../assets/images/dynamic_icons/menu/icon_menu_support_admin.svg\";\nimport menuTodo from \"../assets/images/dynamic_icons/menu/icon_menu_todo.svg\";\nimport menuTools from \"../assets/images/dynamic_icons/menu/icon_menu_tools.svg\";\n\n// Icons Signature Select\nimport checkChecked from \"../assets/images/dynamic_icons/signature_select/icon_check_checked.svg\";\nimport checkEmpty from \"../assets/images/dynamic_icons/signature_select/icon_check_empty.svg\";\nimport signatureDraw from \"../assets/images/dynamic_icons/signature_select/icon_signature_draw.svg\";\nimport signatureDrawActive from \"../assets/images/dynamic_icons/signature_select/icon_signature_draw_active.svg\";\nimport signatureSelect from \"../assets/images/dynamic_icons/signature_select/icon_signature_select.svg\";\nimport signatureSelectActive from \"../assets/images/dynamic_icons/signature_select/icon_signature_select_active.svg\";\n\n// Icons Text Editor\nimport tipTapAlignCenterIcon from \"../assets/images/dynamic_icons/rich_text_editor/align_center_icon.svg\";\nimport tipTapAlignJustifyIcon from \"../assets/images/dynamic_icons/rich_text_editor/align_justify_icon.svg\";\nimport tipTapAlignLeftIcon from \"../assets/images/dynamic_icons/rich_text_editor/align_left_icon.svg\";\nimport tipTapAlignRightIcon from \"../assets/images/dynamic_icons/rich_text_editor/align_right_icon.svg\";\nimport tipTapArrowLeftIcon from \"../assets/images/dynamic_icons/rich_text_editor/arrow_left_icon.svg\";\nimport tipTapBanIcon from \"../assets/images/dynamic_icons/rich_text_editor/ban_icon.svg\";\nimport tipTapBlockQuoteIcon from \"../assets/images/dynamic_icons/rich_text_editor/block_quote_icon.svg\";\nimport tipTapBoldIcon from \"../assets/images/dynamic_icons/rich_text_editor/bold_icon.svg\";\nimport tipTapChevronDownIcon from \"../assets/images/dynamic_icons/rich_text_editor/chevron_down_icon.svg\";\nimport tipTapCloseIcon from \"../assets/images/dynamic_icons/rich_text_editor/close_icon.svg\";\nimport tipTapCode2Icon from \"../assets/images/dynamic_icons/rich_text_editor/code2_icon.svg\";\nimport tipTapCodeBlockIcon from \"../assets/images/dynamic_icons/rich_text_editor/code_block_icon.svg\";\nimport tipTapCornerDownLeftIcon from \"../assets/images/dynamic_icons/rich_text_editor/corner_down_left_icon.svg\";\nimport tipTapEmojiIcon from \"../assets/images/dynamic_icons/rich_text_editor/emoji_icon.svg\";\nimport tipTapExternalLinkIcon from \"../assets/images/dynamic_icons/rich_text_editor/external_link_icon.svg\";\nimport tipTapHeadingFiveIcon from \"../assets/images/dynamic_icons/rich_text_editor/heading_five_icon.svg\";\nimport tipTapHeadingFourIcon from \"../assets/images/dynamic_icons/rich_text_editor/heading_four_icon.svg\";\nimport tipTapHeadingIcon from \"../assets/images/dynamic_icons/rich_text_editor/heading_icon.svg\";\nimport tipTapHeadingOneIcon from \"../assets/images/dynamic_icons/rich_text_editor/heading_one_icon.svg\";\nimport tipTapHeadingSixIcon from \"../assets/images/dynamic_icons/rich_text_editor/heading_six_icon.svg\";\nimport tipTapHeadingThreeIcon from \"../assets/images/dynamic_icons/rich_text_editor/heading_three_icon.svg\";\nimport tipTapHeadingTwoIcon from \"../assets/images/dynamic_icons/rich_text_editor/heading_two_icon.svg\";\nimport tipTapImagePlusIcon from \"../assets/images/dynamic_icons/rich_text_editor/image_plus_icon.svg\";\nimport tipTapItalicIcon from \"../assets/images/dynamic_icons/rich_text_editor/italic_icon.svg\";\nimport tipTapLinkIcon from \"../assets/images/dynamic_icons/rich_text_editor/link_icon.svg\";\nimport tipTapListIcon from \"../assets/images/dynamic_icons/rich_text_editor/list_icon.svg\";\nimport tipTapListOrderedIcon from \"../assets/images/dynamic_icons/rich_text_editor/list_ordered_icon.svg\";\nimport tipTapListTodoIcon from \"../assets/images/dynamic_icons/rich_text_editor/list_todo_icon.svg\";\nimport tipTapRedo2Icon from \"../assets/images/dynamic_icons/rich_text_editor/redo2_icon.svg\";\nimport tipTapStrikeIcon from \"../assets/images/dynamic_icons/rich_text_editor/strike_icon.svg\";\nimport tipTapSubscriptIcon from \"../assets/images/dynamic_icons/rich_text_editor/subscript_icon.svg\";\nimport tipTapSuperscriptIcon from \"../assets/images/dynamic_icons/rich_text_editor/superscript_icon.svg\";\nimport tipTapTableIcon from \"../assets/images/dynamic_icons/rich_text_editor/table_icon.svg\";\nimport tipTapTrashIcon from \"../assets/images/dynamic_icons/rich_text_editor/trash_icon.svg\";\nimport tipTapUnderlineIcon from \"../assets/images/dynamic_icons/rich_text_editor/underline_icon.svg\";\nimport tipTapUndo2Icon from \"../assets/images/dynamic_icons/rich_text_editor/undo2_icon.svg\";\nimport tipTapVideoIcon from \"../assets/images/dynamic_icons/rich_text_editor/video_icon.svg\";\n\n// Illustrations\nimport documentEmpty from \"../assets/images/illustrations/document_empty.svg\";\nimport documentList from \"../assets/images/illustrations/document_list.svg\";\nimport documentPDF from \"../assets/images/illustrations/document_pdf.svg\";\nimport documentScan from \"../assets/images/illustrations/document_scan.svg\";\nimport documentUpload from \"../assets/images/illustrations/document_upload.svg\";\nimport documentValuation from \"../assets/images/illustrations/document_valuation.svg\";\nimport illustrationActionsEmpty from \"../assets/images/illustrations/illustration_actions_empty.png\";\nimport messageEmpty from \"../assets/images/illustrations/message_empty.svg\";\nimport signaturePadPlaceholder from \"../assets/images/illustrations/signature_pad_placeholder.svg\";\nimport cardBackgroundEllipse from \"../assets/images/illustrations/card_background_ellipse.svg\";\n\nimport cakeLogo from \"../assets/cake_logo.png\";\n\n// Dynamic menu icons\nimport menuHeaderCaptable from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_header_captable.svg\";\nimport menuHeaderCompliance from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_header_compliance.svg\";\nimport menuHeaderEngage from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_header_engage.svg\";\nimport menuHeaderIncentives from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_header_incentives.svg\";\nimport menuHeaderGetStarted from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_header_get_started.svg\";\nimport menuHeaderSettings from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_header_settings.svg\";\nimport menuHeaderTools from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_header_tools.svg\";\n\nimport menuBeginnerGetStarted from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_get_started.svg\";\nimport menuBeginnerGroupsAndBoard from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_groups_and_board.svg\";\nimport menuBeginnerSettings from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_settings.svg\";\nimport menuBeginnerTeamHub from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_team_hub.svg\";\nimport menuBeginnerToDo from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_to_do.svg\";\n\nimport menuBeginnerExerciseRequests from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_exercise_requests.svg\";\nimport menuBeginnerOffBoarding from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_off_boarding.svg\";\nimport menuBeginnerPlans from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_plans.svg\";\nimport menuBeginnerBoardApprovals from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_board_approvals.svg\";\nimport menuBeginnerVestingTemplates from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_vesting_templates.svg\";\n\nimport menuBeginnerCapTable from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_cap_table.svg\";\nimport menuBeginnerTransfers from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_transfers.svg\";\nimport menuBeginnerShareClasses from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_share_classes.svg\";\nimport menuBeginnerTransactionLogs from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_transaction_logs.svg\";\nimport menuBeginnerValuations from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_valuations.svg\";\n\nimport menuBeginner409a from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_409a.svg\";\n\nimport menuBeginnerPeople from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_people.svg\";\nimport menuBeginnerCommunication from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_communication.svg\";\nimport menuBeginnerAllDocuments from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_all_documents.svg\";\nimport menuBeginnerTemplates from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_templates.svg\";\n// eslint-disable-next-line max-len\nimport menuBeginnerPendingSignatures from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_pending_signatures.svg\";\nimport menuBeginnerAiScanner from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_ai_scanner.svg\";\n\nimport menuBeginnerModelling from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_modelling.svg\";\nimport menuBeginnerExitEstimator from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_exit_estimator.svg\";\nimport menuBeginnerReporting from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_reporting.svg\";\nimport menuBeginnerEquityBenchmarks from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_equity_benchmarks.svg\";\nimport menuBeginnerAuditLog from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_audit_log.svg\";\nimport menuBeginnerRaise from \"../assets/images/dynamic_icons/menu_beginner/icon_menu_raise.svg\";\n\nconst DynamicIcons = {\n\tadd,\n\taddCircle,\n\talarm,\n\tattachment,\n\tarrowCircle,\n\tarrowsTriangle,\n\tarrow,\n\tarrowSort,\n\tbarLineChart,\n\tcakeStroke,\n\tchat,\n\tcheckBg,\n\tcheckmark,\n\tcheckEmpty,\n\tcheckChecked,\n\tcheckmarkCircle,\n\tchevron,\n\tclose,\n\tcomment,\n\tcommentActive,\n\tcopy,\n\tdeleteIcon,\n\tdocument,\n\tdocumentAdd,\n\tdocumentAttachment,\n\tdocumentCheckmark,\n\tdone,\n\tdoneEggplant,\n\tdoneGrey,\n\tdownload,\n\tedit,\n\teditSquare,\n\teyeSlash,\n\tfiles,\n\tfilters,\n\tfilterStatus,\n\thelp,\n\tinfo,\n\tinfoFill,\n\tpieChart,\n\tpuzzle,\n\tlineChart,\n\tminusCircle,\n\tmore,\n\tmove,\n\tnotification,\n\tnotificationAlert,\n\trefresh,\n\tsearch,\n\tsignatureDraw,\n\tsignatureDrawActive,\n\tsignatureSelect,\n\tsignatureSelectActive,\n\tshield,\n\tusersAdd,\n\tusersCheckmark,\n\tpen,\n\tpencil,\n\tsend,\n\tmenuQuickstart,\n\tmenuDashboard,\n\tmenuCaptable,\n\tmenuPeople,\n\tmenuEquity,\n\tmenuDocuments,\n\tmenuTools,\n\tmenuBoardApprovals,\n\tmenuCommunication,\n\tmenuSettings,\n\tmenuClock,\n\tmenuLiquidityInterest,\n\tmenuSupportAdmin,\n\tmenuInbox,\n\tmenuTodo,\n\tmenuClipboard,\n\tfilter,\n\tdate,\n\talertDynamic,\n\talertTriangle,\n\tflag,\n\ttable,\n\tsettings,\n\tcalculator,\n\tcolumns,\n\tcertificate,\n\tcloseCircle,\n\tthumbs,\n\tvest,\n\tvestStop,\n\tpause,\n\tresume,\n\tcopyPaste,\n\texercise,\n\treset,\n\treminder,\n\toffline,\n\tcaret,\n\ttime,\n\tuserDashed,\n\thandsClapping,\n\tpresentation,\n\tlifeBuoy,\n\tplay,\n\tsquare,\n\tgrid,\n\tscribble,\n\tuser,\n\tuserMultiple,\n\tfileArrowUp,\n\tgear,\n\tnotePencil,\n\tstarOutline,\n\tpercentage,\n\ttrendUp,\n\tcurrencyDollar,\n\tlistMagnifyingGlass,\n\tcheckmarkDashedCircle,\n\tdrag,\n\tenvelope,\n\treply,\n\ttag,\n\trocket,\n\tdowngrade,\n\tlock,\n\tsave,\n\tupload,\n};\n\nconst DynamicMenuIcons = {\n\tmenuHeaderCaptable,\n\tmenuHeaderCompliance,\n\tmenuHeaderEngage,\n\tmenuHeaderIncentives,\n\tmenuHeaderGetStarted,\n\tmenuHeaderSettings,\n\tmenuHeaderTools,\n\tmenuBeginnerGetStarted,\n\tmenuBeginnerGroupsAndBoard,\n\tmenuBeginnerSettings,\n\tmenuBeginnerTeamHub,\n\tmenuBeginnerToDo,\n\tmenuBeginnerExerciseRequests,\n\tmenuBeginnerOffBoarding,\n\tmenuBeginnerPlans,\n\tmenuBeginnerBoardApprovals,\n\tmenuBeginnerVestingTemplates,\n\tmenuBeginnerCapTable,\n\tmenuBeginnerTransfers,\n\tmenuBeginnerShareClasses,\n\tmenuBeginnerTransactionLogs,\n\tmenuBeginnerValuations,\n\tmenuBeginner409a,\n\tmenuBeginnerPeople,\n\tmenuBeginnerCommunication,\n\tmenuBeginnerAllDocuments,\n\tmenuBeginnerTemplates,\n\tmenuBeginnerPendingSignatures,\n\tmenuBeginnerAiScanner,\n\tmenuBeginnerModelling,\n\tmenuBeginnerExitEstimator,\n\tmenuBeginnerReporting,\n\tmenuBeginnerEquityBenchmarks,\n\tmenuBeginnerAuditLog,\n\tmenuBeginnerRaise,\n\tmapPin,\n\tfilterFlag,\n\tidBadge,\n\tphone,\n\tusers,\n};\n\nconst RichTextEditorIcons = {\n\ttipTapAlignCenterIcon,\n\ttipTapAlignJustifyIcon,\n\ttipTapAlignLeftIcon,\n\ttipTapAlignRightIcon,\n\ttipTapArrowLeftIcon,\n\ttipTapBanIcon,\n\ttipTapBlockQuoteIcon,\n\ttipTapBoldIcon,\n\ttipTapChevronDownIcon,\n\ttipTapCloseIcon,\n\ttipTapCodeBlockIcon,\n\ttipTapCode2Icon,\n\ttipTapCornerDownLeftIcon,\n\ttipTapExternalLinkIcon,\n\ttipTapHeadingFiveIcon,\n\ttipTapHeadingFourIcon,\n\ttipTapHeadingIcon,\n\ttipTapHeadingOneIcon,\n\ttipTapHeadingSixIcon,\n\ttipTapHeadingThreeIcon,\n\ttipTapHeadingTwoIcon,\n\ttipTapImagePlusIcon,\n\ttipTapItalicIcon,\n\ttipTapLinkIcon,\n\ttipTapListIcon,\n\ttipTapListOrderedIcon,\n\ttipTapListTodoIcon,\n\ttipTapRedo2Icon,\n\ttipTapStrikeIcon,\n\ttipTapSubscriptIcon,\n\ttipTapSuperscriptIcon,\n\ttipTapTableIcon,\n\ttipTapTrashIcon,\n\ttipTapUndo2Icon,\n\ttipTapUnderlineIcon,\n\ttipTapEmojiIcon,\n\ttipTapVideoIcon,\n};\n\nconst Illustrations = {\n\tsignaturePadPlaceholder,\n\tdocumentPDF,\n\tdocumentScan,\n\tdocumentList,\n\tdocumentEmpty,\n\tmessageEmpty,\n\tillustrationActionsEmpty,\n\tdocumentUpload,\n\tdocumentValuation,\n\tcardBackgroundEllipse,\n};\n\nconst Logos = {\n\tcakeLogo,\n};\n\nexport { DynamicIcons, Illustrations, Logos, RichTextEditorIcons, DynamicMenuIcons };\n","import { ApolloClient, HttpLink, InMemoryCache, NormalizedCacheObject } from \"@apollo/client\";\nimport { OrganisationData, useOrgStore } from \"@base/hooks/useOrgStore\";\nimport { useServerSentEventsStore } from \"@base/hooks/useServerSentEvents\";\nimport axios from \"axios\";\nimport { create } from \"zustand\";\nimport { persist } from \"zustand/middleware\";\n\nexport enum OnboardingStatusType {\n\tNONE = \"NONE\",\n\tRETURNING_USER = \"RETURNING_USER\",\n\tNEW_USER = \"NEW_USER\",\n}\n\ninterface UserState {\n\treadonly id: string;\n\treadonly name: string;\n\treadonly email: string;\n\treadonly picture?: string;\n\treadonly isSupportAdmin: boolean;\n\treadonly hasCompanies: boolean;\n\treadonly onboardingStatus: OnboardingStatusType;\n\treadonly cake_finger?: string;\n\treadonly needsToAcceptNewTerms: boolean;\n\treadonly needsToDismissNewUserScreen: boolean;\n}\n\nconst useUserProfile = create<UserState>()(() => ({\n\tid: \"\",\n\tname: \"\",\n\temail: \"\",\n\tisSupportAdmin: false,\n\thasCompanies: false,\n\tonboardingStatus: OnboardingStatusType.NONE,\n\tneedsToAcceptNewTerms: true,\n\tneedsToDismissNewUserScreen: true,\n}));\n\ninterface AppSharedStore {\n\treadonly apolloClient?: ApolloClient<NormalizedCacheObject>;\n\treadonly csrfToken?: string;\n\treadonly paginationSize: number;\n\treadonly itemsPerLoad: number;\n}\n\ninterface Dictionary<T> {\n\t[Key: string]: T;\n}\n\ninterface AppContext {\n\tCURRENCIES: Dictionary<string>;\n\tCURRENCY_SYMBOLS: Dictionary<string>;\n\tCOUNTRY_LIST: Array<Country>;\n\tGOOGLE_CLOUD_PLATFORM_KEY: string;\n\tSENTRY_DSN: string;\n\tAPP_ENDPOINT: string;\n\tBASE_DOMAIN_URL: string;\n\tPLATFORM_VERSION: string;\n\tAPP_ENVIRONMENT: string;\n\tSW_URL: string;\n\tAPP_SEGMENT: \"founder\" | \"employee\" | \"unknown\";\n\tSKIP_ANALYTICS: boolean;\n\tcsrf_token: string;\n\tDEFAULT_SELECTED_COMPANY_ID: string;\n\tAUTHENTICATED_USER: UserState | null;\n\tORG_DATA: OrganisationData | null; // Organisation data, if available\n\tCOMMAND_CENTER_FRONTEND_REFRESH_IN_MILLIS: number;\n\tSKIP_SSE_ORG_CHECK: boolean;\n\tPOSITIONS_LIST?: { position: string; description: string }[];\n\tROLES_LIST?: { role: string; description: string }[];\n\t[key: string]: unknown; // Allow additional dynamic keys safely\n}\n\nconst OBFUSCATION_KEY = \"c0n73x7k3y\";\n\nfunction decodeXorFromHex(hex: string, key: string): string {\n\tconst bytes = hex.match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) ?? [];\n\tconst decodedChars = bytes.map((byte, i) => String.fromCharCode(byte ^ key.charCodeAt(i % key.length)));\n\treturn decodedChars.join(\"\");\n}\n\nfunction loadAppContext(): AppContext | null {\n\tconst el = document.getElementById(\"initialContext\");\n\tif (!el) return null;\n\n\tconst hex = el.textContent?.trim() ?? \"\";\n\ttry {\n\t\tconst json = decodeXorFromHex(hex, OBFUSCATION_KEY);\n\t\tconst decoded = JSON.parse(json);\n\t\treturn decoded;\n\t} catch (e) {\n\t\tconsole.error(\"Failed to decode app context:\", e);\n\t\treturn null;\n\t}\n}\n\nconst useAppConfig = create<AppSharedStore>()(() => ({\n\tpaginationSize: 0,\n\titemsPerLoad: 0,\n}));\n\ninterface Country {\n\tcode: string;\n\tname: string;\n}\n\ntype SkinToneKey = \"dark\" | \"light\" | \"medium-dark\" | \"medium-light\" | \"medium\" | \"none\";\ninterface UserPreferences {\n\tuserCurrency: string;\n\tsetUserCurrency: (new_currency: string) => void;\n\temployeeGoalFeedbackUsage: boolean;\n\tsetEmployeeGoalFeedbackUsage: (new_value: boolean) => void;\n\tskinTone: SkinToneKey;\n\tsetSkinTone: (tone: SkinToneKey) => void;\n}\n\nconst useUserPreferences = create<UserPreferences>()(\n\tpersist(\n\t\t(set) => ({\n\t\t\tuserCurrency: \"\",\n\t\t\tsetUserCurrency: (new_currency) => set({ userCurrency: new_currency }),\n\t\t\temployeeGoalFeedbackUsage: false,\n\t\t\tsetEmployeeGoalFeedbackUsage: (new_value) => set({ employeeGoalFeedbackUsage: new_value }),\n\t\t\tskinTone: \"none\",\n\t\t\tsetSkinTone: (tone) => set({ skinTone: tone }),\n\t\t}),\n\t\t{\n\t\t\tname: \"EMPLOYEE_APP_USER_PREFERENCES\",\n\t\t}\n\t)\n);\n\ninterface UnauthenticatedStore {\n\thideHeader: boolean;\n\tsetHideHeader: (hide: boolean) => void;\n}\n\nconst useUnauthenticatedStore = create<UnauthenticatedStore>((set) => ({\n\thideHeader: false,\n\tsetHideHeader: (hide: boolean) => set({ hideHeader: hide }),\n}));\n\nconst appContext = loadAppContext();\nconst getAppContext = () => {\n\treturn appContext;\n};\n\nconst initializeCakeStores = () => {\n\tif (appContext === null) {\n\t\treturn;\n\t}\n\n\tconst authenticatedUser = appContext.AUTHENTICATED_USER;\n\tif (authenticatedUser !== null) {\n\t\tuseUserProfile.setState(() => authenticatedUser, true);\n\t}\n\n\ttry {\n\t\tconst httpLink = new HttpLink({\n\t\t\theaders: {\n\t\t\t\t\"X-CSRFToken\": appContext.csrf_token,\n\t\t\t},\n\t\t\turi: `${appContext.BASE_DOMAIN_URL}/graphql`,\n\t\t\tfetch: async (uri, options) => {\n\t\t\t\tconst response = await fetch(uri, options);\n\t\t\t\tif (response.headers.get(\"X-Maintenance-Mode\")) {\n\t\t\t\t\tconsole.debug(\"Maintenance mode detected, reloading page\");\n\t\t\t\t\twindow.location.reload();\n\t\t\t\t\tthrow new Error(\"We're performing maintenance. We'll be right back!\");\n\t\t\t\t}\n\t\t\t\treturn response;\n\t\t\t},\n\t\t});\n\t\tconst apolloCache = new InMemoryCache({\n\t\t\ttypePolicies: {\n\t\t\t\tQuery: {\n\t\t\t\t\tfields: {\n\t\t\t\t\t\torganisation: {\n\t\t\t\t\t\t\tmerge: false,\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\t/*\n                    If we get EsopOffer objects with different fields from different requests,\n                    they would cache bust each other. Therefore, `keyFields: false` for those.\n                    https://www.apollographql.com/docs/react/caching/cache-configuration/#disabling-normalization\n                */\n\t\t\t\tEsopOffer: {\n\t\t\t\t\tkeyFields: false,\n\t\t\t\t},\n\t\t\t\tEssOffer: {\n\t\t\t\t\tkeyFields: false,\n\t\t\t\t},\n\t\t\t\tOrganisationRaiseOffer: {\n\t\t\t\t\tkeyFields: false,\n\t\t\t\t},\n\t\t\t\tNotesRoundOffer: {\n\t\t\t\t\tkeyFields: false,\n\t\t\t\t},\n\t\t\t\tShareTransferOfferType: {\n\t\t\t\t\tkeyFields: false,\n\t\t\t\t},\n\t\t\t\tShareholder: {\n\t\t\t\t\tkeyFields: false,\n\t\t\t\t},\n\t\t\t\tBoardApprovalType: {\n\t\t\t\t\tkeyFields: false,\n\t\t\t\t},\n\t\t\t\tBillingShareholderType: {\n\t\t\t\t\tkeyFields: false,\n\t\t\t\t},\n\t\t\t\tSharetypeHoldingType: {\n\t\t\t\t\tkeyFields: false,\n\t\t\t\t},\n\t\t\t\tStakeholderAssetsPreviewType: {\n\t\t\t\t\tkeyFields: false,\n\t\t\t\t},\n\t\t\t\tStakeholderVestablePlanHoldingsType: {\n\t\t\t\t\tkeyFields: false,\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t\tconst networkStoreInitiaState: AppSharedStore = {\n\t\t\tcsrfToken: appContext.csrf_token,\n\t\t\tapolloClient: new ApolloClient({\n\t\t\t\tlink: httpLink,\n\t\t\t\tcache: apolloCache,\n\t\t\t}),\n\t\t\tpaginationSize: 24,\n\t\t\titemsPerLoad: 2,\n\t\t};\n\t\tuseAppConfig.setState(networkStoreInitiaState, true);\n\t\taxios.defaults.xsrfCookieName = \"csrftoken\";\n\t\taxios.defaults.xsrfHeaderName = \"X-CSRFToken\";\n\t\taxios.defaults.withXSRFToken = true;\n\t} catch (error) {\n\t\tconsole.error(\"Error initializing useAppConfig\", error);\n\t}\n\n\tif (appContext.ORG_DATA) {\n\t\tuseOrgStore.getState().initialize(appContext.ORG_DATA);\n\t}\n\n\tconst userId = useUserProfile.getState()?.id;\n\tif (userId) {\n\t\tuseServerSentEventsStore.getState().sse.initialize(userId, Boolean(appContext.SKIP_SSE_ORG_CHECK));\n\t}\n};\n\nexport {\n\tgetAppContext,\n\tinitializeCakeStores,\n\tuseAppConfig,\n\tuseUnauthenticatedStore,\n\tuseUserPreferences,\n\tuseUserProfile,\n\ttype AppContext,\n\ttype Country,\n};\n","// extracted by mini-css-extract-plugin\nexport default {\"icon\":\"icon--Icon-module--_NJUl\",\"height--100x\":\"height--100x--Icon-module--bJACk\",\"width--100x\":\"width--100x--Icon-module--Ug5F4\",\"size--100x\":\"size--100x--Icon-module--QzY01\",\"height--99x\":\"height--99x--Icon-module--sAsrh\",\"width--99x\":\"width--99x--Icon-module--Q6eCC\",\"size--99x\":\"size--99x--Icon-module--H4ER_\",\"height--98x\":\"height--98x--Icon-module--RU3Ea\",\"width--98x\":\"width--98x--Icon-module--k5YUc\",\"size--98x\":\"size--98x--Icon-module--EvYvu\",\"height--97x\":\"height--97x--Icon-module--rNBo9\",\"width--97x\":\"width--97x--Icon-module--doaM5\",\"size--97x\":\"size--97x--Icon-module--V0m_d\",\"height--96x\":\"height--96x--Icon-module--BKfbN\",\"width--96x\":\"width--96x--Icon-module--a7VKf\",\"size--96x\":\"size--96x--Icon-module--Gy2OR\",\"height--95x\":\"height--95x--Icon-module--jmFTB\",\"width--95x\":\"width--95x--Icon-module--SJiGW\",\"size--95x\":\"size--95x--Icon-module--xQZTG\",\"height--94x\":\"height--94x--Icon-module--gcW48\",\"width--94x\":\"width--94x--Icon-module--SgtHM\",\"size--94x\":\"size--94x--Icon-module--anqEc\",\"height--93x\":\"height--93x--Icon-module--Oz4Kv\",\"width--93x\":\"width--93x--Icon-module--h549M\",\"size--93x\":\"size--93x--Icon-module--rbVFF\",\"height--92x\":\"height--92x--Icon-module--wZ1NQ\",\"width--92x\":\"width--92x--Icon-module--egkj3\",\"size--92x\":\"size--92x--Icon-module--aJJuJ\",\"height--91x\":\"height--91x--Icon-module--t1fOt\",\"width--91x\":\"width--91x--Icon-module--pNsxd\",\"size--91x\":\"size--91x--Icon-module--Okr4T\",\"height--90x\":\"height--90x--Icon-module--RI6R2\",\"width--90x\":\"width--90x--Icon-module--NExmZ\",\"size--90x\":\"size--90x--Icon-module--jqJ1p\",\"height--89x\":\"height--89x--Icon-module--_10jk\",\"width--89x\":\"width--89x--Icon-module--Jftga\",\"size--89x\":\"size--89x--Icon-module--vQzCd\",\"height--88x\":\"height--88x--Icon-module--DQvFi\",\"width--88x\":\"width--88x--Icon-module--_RvN9\",\"size--88x\":\"size--88x--Icon-module--sQ_9D\",\"height--87x\":\"height--87x--Icon-module--Zht3q\",\"width--87x\":\"width--87x--Icon-module--Y2nEn\",\"size--87x\":\"size--87x--Icon-module--AYAqs\",\"height--86x\":\"height--86x--Icon-module--D5qyT\",\"width--86x\":\"width--86x--Icon-module--kwMQ6\",\"size--86x\":\"size--86x--Icon-module--aNA2u\",\"height--85x\":\"height--85x--Icon-module--VYGdQ\",\"width--85x\":\"width--85x--Icon-module--LMcEn\",\"size--85x\":\"size--85x--Icon-module--Hs4KQ\",\"height--84x\":\"height--84x--Icon-module--Gx_66\",\"width--84x\":\"width--84x--Icon-module--sZ12B\",\"size--84x\":\"size--84x--Icon-module--NgJNU\",\"height--83x\":\"height--83x--Icon-module--tT6G1\",\"width--83x\":\"width--83x--Icon-module--C4Tn_\",\"size--83x\":\"size--83x--Icon-module--PPHzp\",\"height--82x\":\"height--82x--Icon-module--WQ9eR\",\"width--82x\":\"width--82x--Icon-module--NGK99\",\"size--82x\":\"size--82x--Icon-module--sfwbA\",\"height--81x\":\"height--81x--Icon-module--yQSOl\",\"width--81x\":\"width--81x--Icon-module--Ehsb3\",\"size--81x\":\"size--81x--Icon-module--KlbMG\",\"height--80x\":\"height--80x--Icon-module--KdKz0\",\"width--80x\":\"width--80x--Icon-module--hnT3v\",\"size--80x\":\"size--80x--Icon-module--kam3Z\",\"height--79x\":\"height--79x--Icon-module--Q6XIy\",\"width--79x\":\"width--79x--Icon-module--v1MeU\",\"size--79x\":\"size--79x--Icon-module--viI2P\",\"height--78x\":\"height--78x--Icon-module--MLE9v\",\"width--78x\":\"width--78x--Icon-module--HH4Bd\",\"size--78x\":\"size--78x--Icon-module--lpQd9\",\"height--77x\":\"height--77x--Icon-module--A58GL\",\"width--77x\":\"width--77x--Icon-module--jjjtR\",\"size--77x\":\"size--77x--Icon-module--OCuAI\",\"height--76x\":\"height--76x--Icon-module--VLMuO\",\"width--76x\":\"width--76x--Icon-module--rwS8C\",\"size--76x\":\"size--76x--Icon-module--tZmWy\",\"height--75x\":\"height--75x--Icon-module--HeEH9\",\"width--75x\":\"width--75x--Icon-module--ZcrRt\",\"size--75x\":\"size--75x--Icon-module--N4A5T\",\"height--74x\":\"height--74x--Icon-module--PR95F\",\"width--74x\":\"width--74x--Icon-module--iKQUe\",\"size--74x\":\"size--74x--Icon-module--TlowP\",\"height--73x\":\"height--73x--Icon-module--oJl21\",\"width--73x\":\"width--73x--Icon-module--syL21\",\"size--73x\":\"size--73x--Icon-module--fS6yj\",\"height--72x\":\"height--72x--Icon-module--vKti6\",\"width--72x\":\"width--72x--Icon-module--zqbCx\",\"size--72x\":\"size--72x--Icon-module--sCffE\",\"height--71x\":\"height--71x--Icon-module--TKWqO\",\"width--71x\":\"width--71x--Icon-module--PWYjK\",\"size--71x\":\"size--71x--Icon-module--Y5e7N\",\"height--70x\":\"height--70x--Icon-module--FX2eL\",\"width--70x\":\"width--70x--Icon-module--jTxh0\",\"size--70x\":\"size--70x--Icon-module--W9QUX\",\"height--69x\":\"height--69x--Icon-module--nCKvp\",\"width--69x\":\"width--69x--Icon-module--T7Jd0\",\"size--69x\":\"size--69x--Icon-module--_OVpH\",\"height--68x\":\"height--68x--Icon-module--L3MyE\",\"width--68x\":\"width--68x--Icon-module--J75tk\",\"size--68x\":\"size--68x--Icon-module--zsqT7\",\"height--67x\":\"height--67x--Icon-module--VnrQH\",\"width--67x\":\"width--67x--Icon-module--R6I50\",\"size--67x\":\"size--67x--Icon-module--wj2O8\",\"height--66x\":\"height--66x--Icon-module--ApH85\",\"width--66x\":\"width--66x--Icon-module--s_lpN\",\"size--66x\":\"size--66x--Icon-module--rkQkX\",\"height--65x\":\"height--65x--Icon-module--VUVQP\",\"width--65x\":\"width--65x--Icon-module--Ci5yk\",\"size--65x\":\"size--65x--Icon-module--cKZZK\",\"height--64x\":\"height--64x--Icon-module--vgRcl\",\"width--64x\":\"width--64x--Icon-module--u0wPP\",\"size--64x\":\"size--64x--Icon-module--_mGf2\",\"height--63x\":\"height--63x--Icon-module--y1V_S\",\"width--63x\":\"width--63x--Icon-module--xvWR5\",\"size--63x\":\"size--63x--Icon-module--b6wvM\",\"height--62x\":\"height--62x--Icon-module--vNkVv\",\"width--62x\":\"width--62x--Icon-module--NIlGK\",\"size--62x\":\"size--62x--Icon-module--UEzwv\",\"height--61x\":\"height--61x--Icon-module--Z2ZJq\",\"width--61x\":\"width--61x--Icon-module--PRxB2\",\"size--61x\":\"size--61x--Icon-module--ZZY61\",\"height--60x\":\"height--60x--Icon-module--v9GuB\",\"width--60x\":\"width--60x--Icon-module--RIEx9\",\"size--60x\":\"size--60x--Icon-module--BhblX\",\"height--59x\":\"height--59x--Icon-module--QiL27\",\"width--59x\":\"width--59x--Icon-module--n4qoB\",\"size--59x\":\"size--59x--Icon-module--ryf6_\",\"height--58x\":\"height--58x--Icon-module--vF7BP\",\"width--58x\":\"width--58x--Icon-module--njayp\",\"size--58x\":\"size--58x--Icon-module--yxcWA\",\"height--57x\":\"height--57x--Icon-module--zRo7d\",\"width--57x\":\"width--57x--Icon-module--ecG2q\",\"size--57x\":\"size--57x--Icon-module--rTV9h\",\"height--56x\":\"height--56x--Icon-module--OuijK\",\"width--56x\":\"width--56x--Icon-module--eUwcx\",\"size--56x\":\"size--56x--Icon-module--Fw99d\",\"height--55x\":\"height--55x--Icon-module--PeKF1\",\"width--55x\":\"width--55x--Icon-module--IMkCZ\",\"size--55x\":\"size--55x--Icon-module--Rllcz\",\"height--54x\":\"height--54x--Icon-module--PkAM8\",\"width--54x\":\"width--54x--Icon-module--xyC9d\",\"size--54x\":\"size--54x--Icon-module--DwkTq\",\"height--53x\":\"height--53x--Icon-module--lt8pp\",\"width--53x\":\"width--53x--Icon-module--ddbly\",\"size--53x\":\"size--53x--Icon-module--Xy_Nu\",\"height--52x\":\"height--52x--Icon-module--N8M64\",\"width--52x\":\"width--52x--Icon-module--tG1uQ\",\"size--52x\":\"size--52x--Icon-module--G8hB2\",\"height--51x\":\"height--51x--Icon-module--WH_pK\",\"width--51x\":\"width--51x--Icon-module--OwB_T\",\"size--51x\":\"size--51x--Icon-module--YU5Jm\",\"height--50x\":\"height--50x--Icon-module--DJ0Im\",\"width--50x\":\"width--50x--Icon-module--M201O\",\"size--50x\":\"size--50x--Icon-module--oRBZQ\",\"height--49x\":\"height--49x--Icon-module--AutoD\",\"width--49x\":\"width--49x--Icon-module--fuQIo\",\"size--49x\":\"size--49x--Icon-module--bV7Yo\",\"height--48x\":\"height--48x--Icon-module--UgsuY\",\"width--48x\":\"width--48x--Icon-module--dNTOv\",\"size--48x\":\"size--48x--Icon-module--SQzMP\",\"height--47x\":\"height--47x--Icon-module--Vvvym\",\"width--47x\":\"width--47x--Icon-module--kIG3A\",\"size--47x\":\"size--47x--Icon-module--XFj4Q\",\"height--46x\":\"height--46x--Icon-module--KHq2M\",\"width--46x\":\"width--46x--Icon-module--OAX3_\",\"size--46x\":\"size--46x--Icon-module--vxTZu\",\"height--45x\":\"height--45x--Icon-module--MU1Wb\",\"width--45x\":\"width--45x--Icon-module--uT_cn\",\"size--45x\":\"size--45x--Icon-module--E2px2\",\"height--44x\":\"height--44x--Icon-module--GLYe4\",\"width--44x\":\"width--44x--Icon-module--rbmLj\",\"size--44x\":\"size--44x--Icon-module--dK0rx\",\"height--43x\":\"height--43x--Icon-module--N7do5\",\"width--43x\":\"width--43x--Icon-module--_6vR5\",\"size--43x\":\"size--43x--Icon-module--c0rMr\",\"height--42x\":\"height--42x--Icon-module--D0zbX\",\"width--42x\":\"width--42x--Icon-module--SkZOr\",\"size--42x\":\"size--42x--Icon-module--_80pT\",\"height--41x\":\"height--41x--Icon-module--L681p\",\"width--41x\":\"width--41x--Icon-module--JJrDb\",\"size--41x\":\"size--41x--Icon-module--DmNZO\",\"height--40x\":\"height--40x--Icon-module--cLHfc\",\"width--40x\":\"width--40x--Icon-module--cXpK6\",\"size--40x\":\"size--40x--Icon-module--D9XMF\",\"height--39x\":\"height--39x--Icon-module--pXtsa\",\"width--39x\":\"width--39x--Icon-module--wH3AV\",\"size--39x\":\"size--39x--Icon-module--DiI7r\",\"height--38x\":\"height--38x--Icon-module--RojW8\",\"width--38x\":\"width--38x--Icon-module--_JDnp\",\"size--38x\":\"size--38x--Icon-module--gVDKL\",\"height--37x\":\"height--37x--Icon-module--qr9rK\",\"width--37x\":\"width--37x--Icon-module--EhEnO\",\"size--37x\":\"size--37x--Icon-module--_ZaQQ\",\"height--36x\":\"height--36x--Icon-module--Oy3eT\",\"width--36x\":\"width--36x--Icon-module--za4xD\",\"size--36x\":\"size--36x--Icon-module--LoaI9\",\"height--35x\":\"height--35x--Icon-module--tB1sd\",\"width--35x\":\"width--35x--Icon-module--ujJka\",\"size--35x\":\"size--35x--Icon-module--Oja2g\",\"height--34x\":\"height--34x--Icon-module--MOp1T\",\"width--34x\":\"width--34x--Icon-module--rdii9\",\"size--34x\":\"size--34x--Icon-module--zCIfS\",\"height--33x\":\"height--33x--Icon-module--iGoAP\",\"width--33x\":\"width--33x--Icon-module--djcwm\",\"size--33x\":\"size--33x--Icon-module--8eSoa\",\"height--32x\":\"height--32x--Icon-module--QApXp\",\"width--32x\":\"width--32x--Icon-module--XKd75\",\"size--32x\":\"size--32x--Icon-module--__tZ5\",\"height--31x\":\"height--31x--Icon-module--izvOf\",\"width--31x\":\"width--31x--Icon-module--afS3j\",\"size--31x\":\"size--31x--Icon-module--zGDoQ\",\"height--30x\":\"height--30x--Icon-module--M8KMF\",\"width--30x\":\"width--30x--Icon-module--tOjQO\",\"size--30x\":\"size--30x--Icon-module--mn714\",\"height--29x\":\"height--29x--Icon-module--YSdbg\",\"width--29x\":\"width--29x--Icon-module--VlMBk\",\"size--29x\":\"size--29x--Icon-module--OWT1R\",\"height--28x\":\"height--28x--Icon-module--y4VJW\",\"width--28x\":\"width--28x--Icon-module--p0lBD\",\"size--28x\":\"size--28x--Icon-module--SK9P3\",\"height--27x\":\"height--27x--Icon-module--oTBi8\",\"width--27x\":\"width--27x--Icon-module--zjmBG\",\"size--27x\":\"size--27x--Icon-module--KU157\",\"height--26x\":\"height--26x--Icon-module--ZPNBG\",\"width--26x\":\"width--26x--Icon-module--sU04A\",\"size--26x\":\"size--26x--Icon-module--VHLc1\",\"height--25x\":\"height--25x--Icon-module--p_zrf\",\"width--25x\":\"width--25x--Icon-module--M3TDz\",\"size--25x\":\"size--25x--Icon-module--YSJgq\",\"height--24x\":\"height--24x--Icon-module--X11xX\",\"width--24x\":\"width--24x--Icon-module--QMbSJ\",\"size--24x\":\"size--24x--Icon-module--BxbEZ\",\"height--23x\":\"height--23x--Icon-module--dguOf\",\"width--23x\":\"width--23x--Icon-module--TSWhO\",\"size--23x\":\"size--23x--Icon-module--ck91m\",\"height--22x\":\"height--22x--Icon-module--BToSA\",\"width--22x\":\"width--22x--Icon-module--Yp5Tn\",\"size--22x\":\"size--22x--Icon-module--ASB1h\",\"height--21x\":\"height--21x--Icon-module--fr1Ef\",\"width--21x\":\"width--21x--Icon-module--f7bsi\",\"size--21x\":\"size--21x--Icon-module--eLIsU\",\"height--20x\":\"height--20x--Icon-module--Umsc1\",\"width--20x\":\"width--20x--Icon-module--KjWAi\",\"size--20x\":\"size--20x--Icon-module--z8Gey\",\"height--19x\":\"height--19x--Icon-module--eZutZ\",\"width--19x\":\"width--19x--Icon-module--qzlCq\",\"size--19x\":\"size--19x--Icon-module--PrMI6\",\"height--18x\":\"height--18x--Icon-module--KtGYK\",\"width--18x\":\"width--18x--Icon-module--Bc2he\",\"size--18x\":\"size--18x--Icon-module--j3SyX\",\"height--17x\":\"height--17x--Icon-module--BS7VZ\",\"width--17x\":\"width--17x--Icon-module--qjXDR\",\"size--17x\":\"size--17x--Icon-module--buXsw\",\"height--16x\":\"height--16x--Icon-module--pciMD\",\"width--16x\":\"width--16x--Icon-module--btsZ3\",\"size--16x\":\"size--16x--Icon-module--hc4Em\",\"height--15x\":\"height--15x--Icon-module--liyMS\",\"width--15x\":\"width--15x--Icon-module--F8IzT\",\"size--15x\":\"size--15x--Icon-module--PkAQo\",\"height--14x\":\"height--14x--Icon-module--Wx2P0\",\"width--14x\":\"width--14x--Icon-module--x5L5J\",\"size--14x\":\"size--14x--Icon-module--qPyTp\",\"height--13x\":\"height--13x--Icon-module--uO7eM\",\"width--13x\":\"width--13x--Icon-module--omZ6l\",\"size--13x\":\"size--13x--Icon-module--P78Dd\",\"height--12x\":\"height--12x--Icon-module--eaoQl\",\"width--12x\":\"width--12x--Icon-module--LnzWg\",\"size--12x\":\"size--12x--Icon-module--GXmnJ\",\"height--11x\":\"height--11x--Icon-module--ZXYU5\",\"width--11x\":\"width--11x--Icon-module--RI1WJ\",\"size--11x\":\"size--11x--Icon-module--QJj5k\",\"height--10x\":\"height--10x--Icon-module--iX5ol\",\"width--10x\":\"width--10x--Icon-module--BFWJn\",\"size--10x\":\"size--10x--Icon-module--bsmoc\",\"height--9x\":\"height--9x--Icon-module--ECKnO\",\"width--9x\":\"width--9x--Icon-module--vbRrc\",\"size--9x\":\"size--9x--Icon-module--YEdPx\",\"height--8x\":\"height--8x--Icon-module--h8Hm_\",\"width--8x\":\"width--8x--Icon-module--KJFRQ\",\"size--8x\":\"size--8x--Icon-module--Y9OKw\",\"height--7x\":\"height--7x--Icon-module--W4YjX\",\"width--7x\":\"width--7x--Icon-module--DwJQE\",\"size--7x\":\"size--7x--Icon-module--KNABv\",\"height--6x\":\"height--6x--Icon-module--zpG1p\",\"width--6x\":\"width--6x--Icon-module--PlX0w\",\"size--6x\":\"size--6x--Icon-module--ZvdHE\",\"height--5x\":\"height--5x--Icon-module--QqzBq\",\"width--5x\":\"width--5x--Icon-module--ByaUs\",\"size--5x\":\"size--5x--Icon-module--bj6Nf\",\"height--4x\":\"height--4x--Icon-module--JqqmS\",\"width--4x\":\"width--4x--Icon-module--Jeuo4\",\"size--4x\":\"size--4x--Icon-module--ydpEP\",\"height--3x\":\"height--3x--Icon-module--NOUgY\",\"width--3x\":\"width--3x--Icon-module--DFbNG\",\"size--3x\":\"size--3x--Icon-module--N_8wT\",\"height--2x\":\"height--2x--Icon-module--E8QAU\",\"width--2x\":\"width--2x--Icon-module--tn8CB\",\"size--2x\":\"size--2x--Icon-module--MlanW\",\"height--1x\":\"height--1x--Icon-module--OsLE7\",\"width--1x\":\"width--1x--Icon-module--Y1T27\",\"size--1x\":\"size--1x--Icon-module--oPaqd\",\"height--05x\":\"height--05x--Icon-module--ireyW\",\"width--05x\":\"width--05x--Icon-module--f6LSa\",\"size--05x\":\"size--05x--Icon-module--s6LPf\",\"height--025x\":\"height--025x--Icon-module--eH6Rz\",\"width--025x\":\"width--025x--Icon-module--FM2bG\",\"size--025x\":\"size--025x--Icon-module--Z2kCs\",\"height-0x\":\"height-0x--Icon-module--ta83O\",\"width-0x\":\"width-0x--Icon-module--OEQBr\",\"size-0x\":\"size-0x--Icon-module--rXyOu\",\"height-0\":\"height-0--Icon-module--yyBc7\",\"width-0\":\"width-0--Icon-module--E4TsF\",\"size-0\":\"size-0--Icon-module--howHU\",\"height-025x\":\"height-025x--Icon-module--JNaCx\",\"width-025x\":\"width-025x--Icon-module--gqwc9\",\"size-025x\":\"size-025x--Icon-module--ClsSL\",\"height-05x\":\"height-05x--Icon-module--Uu24G\",\"width-05x\":\"width-05x--Icon-module--NBv4U\",\"size-05x\":\"size-05x--Icon-module--seUsS\",\"height-1x\":\"height-1x--Icon-module--PKpeY\",\"width-1x\":\"width-1x--Icon-module--iZYlC\",\"size-1x\":\"size-1x--Icon-module--H8ut4\",\"height-2x\":\"height-2x--Icon-module--HyUav\",\"width-2x\":\"width-2x--Icon-module--PsLeD\",\"size-2x\":\"size-2x--Icon-module--l_ORk\",\"height-3x\":\"height-3x--Icon-module--gmcis\",\"width-3x\":\"width-3x--Icon-module--wuX9Q\",\"size-3x\":\"size-3x--Icon-module--asWUR\",\"height-4x\":\"height-4x--Icon-module--wURMb\",\"width-4x\":\"width-4x--Icon-module--kVn04\",\"size-4x\":\"size-4x--Icon-module--c8iz4\",\"height-5x\":\"height-5x--Icon-module--SVwsH\",\"width-5x\":\"width-5x--Icon-module--B0rpt\",\"size-5x\":\"size-5x--Icon-module--kZdq7\",\"height-6x\":\"height-6x--Icon-module--tnnPf\",\"width-6x\":\"width-6x--Icon-module--fNMgK\",\"size-6x\":\"size-6x--Icon-module--KyoTM\",\"height-7x\":\"height-7x--Icon-module--pA5ko\",\"width-7x\":\"width-7x--Icon-module--bKh6f\",\"size-7x\":\"size-7x--Icon-module--AQE_a\",\"height-8x\":\"height-8x--Icon-module--RgPFd\",\"width-8x\":\"width-8x--Icon-module--qSH9e\",\"size-8x\":\"size-8x--Icon-module--TcAl2\",\"height-9x\":\"height-9x--Icon-module--DhD_u\",\"width-9x\":\"width-9x--Icon-module--YuBKv\",\"size-9x\":\"size-9x--Icon-module--wuxjU\",\"height-10x\":\"height-10x--Icon-module--AHwcS\",\"width-10x\":\"width-10x--Icon-module--ZOx4s\",\"size-10x\":\"size-10x--Icon-module--oZbIV\",\"height-11x\":\"height-11x--Icon-module--gX_5K\",\"width-11x\":\"width-11x--Icon-module--wcLgN\",\"size-11x\":\"size-11x--Icon-module--L7LAQ\",\"height-12x\":\"height-12x--Icon-module--hh09g\",\"width-12x\":\"width-12x--Icon-module--h6OiA\",\"size-12x\":\"size-12x--Icon-module--r84Li\",\"height-13x\":\"height-13x--Icon-module--Md6Qq\",\"width-13x\":\"width-13x--Icon-module--Bd_L_\",\"size-13x\":\"size-13x--Icon-module--BbK0F\",\"height-14x\":\"height-14x--Icon-module--KgduT\",\"width-14x\":\"width-14x--Icon-module--IUVCv\",\"size-14x\":\"size-14x--Icon-module--XMqNJ\",\"height-15x\":\"height-15x--Icon-module--dxd6Q\",\"width-15x\":\"width-15x--Icon-module--FqS5T\",\"size-15x\":\"size-15x--Icon-module--Kc7xH\",\"height-16x\":\"height-16x--Icon-module--LqdsK\",\"width-16x\":\"width-16x--Icon-module--crzQp\",\"size-16x\":\"size-16x--Icon-module--zOwNF\",\"height-17x\":\"height-17x--Icon-module--NnF31\",\"width-17x\":\"width-17x--Icon-module--PBbWr\",\"size-17x\":\"size-17x--Icon-module--c1yar\",\"height-18x\":\"height-18x--Icon-module--i4ohE\",\"width-18x\":\"width-18x--Icon-module--_LSMr\",\"size-18x\":\"size-18x--Icon-module--R4Jil\",\"height-19x\":\"height-19x--Icon-module--XdxQR\",\"width-19x\":\"width-19x--Icon-module--QVJ1u\",\"size-19x\":\"size-19x--Icon-module--enzXR\",\"height-20x\":\"height-20x--Icon-module--esnSS\",\"width-20x\":\"width-20x--Icon-module--DJRie\",\"size-20x\":\"size-20x--Icon-module--xg_K3\",\"height-21x\":\"height-21x--Icon-module--kBjNr\",\"width-21x\":\"width-21x--Icon-module--bgvLM\",\"size-21x\":\"size-21x--Icon-module--TF5tv\",\"height-22x\":\"height-22x--Icon-module--LiHKH\",\"width-22x\":\"width-22x--Icon-module--Za_ja\",\"size-22x\":\"size-22x--Icon-module--y6Yhx\",\"height-23x\":\"height-23x--Icon-module--DydO5\",\"width-23x\":\"width-23x--Icon-module--Dkd8m\",\"size-23x\":\"size-23x--Icon-module--HMJBB\",\"height-24x\":\"height-24x--Icon-module--KWPFU\",\"width-24x\":\"width-24x--Icon-module--GF7NO\",\"size-24x\":\"size-24x--Icon-module--gtwxd\",\"height-25x\":\"height-25x--Icon-module--fVm0y\",\"width-25x\":\"width-25x--Icon-module--JteEo\",\"size-25x\":\"size-25x--Icon-module--i0YG4\",\"height-26x\":\"height-26x--Icon-module--TCeX0\",\"width-26x\":\"width-26x--Icon-module--gUQmk\",\"size-26x\":\"size-26x--Icon-module--fncPx\",\"height-27x\":\"height-27x--Icon-module--Ddxmq\",\"width-27x\":\"width-27x--Icon-module--QQSZG\",\"size-27x\":\"size-27x--Icon-module--RF8Zl\",\"height-28x\":\"height-28x--Icon-module--SSX38\",\"width-28x\":\"width-28x--Icon-module--k1g9V\",\"size-28x\":\"size-28x--Icon-module--hljuc\",\"height-29x\":\"height-29x--Icon-module--UJT8a\",\"width-29x\":\"width-29x--Icon-module--PxQ4r\",\"size-29x\":\"size-29x--Icon-module--L9D8B\",\"height-30x\":\"height-30x--Icon-module--Nxx3j\",\"width-30x\":\"width-30x--Icon-module--duhPu\",\"size-30x\":\"size-30x--Icon-module--K8oFY\",\"height-31x\":\"height-31x--Icon-module--BA5ib\",\"width-31x\":\"width-31x--Icon-module--jpsRJ\",\"size-31x\":\"size-31x--Icon-module--UeBfX\",\"height-32x\":\"height-32x--Icon-module--H6yz0\",\"width-32x\":\"width-32x--Icon-module--gBQZR\",\"size-32x\":\"size-32x--Icon-module--b40sy\",\"height-33x\":\"height-33x--Icon-module--GRM9h\",\"width-33x\":\"width-33x--Icon-module--m1ovG\",\"size-33x\":\"size-33x--Icon-module--ZEXpP\",\"height-34x\":\"height-34x--Icon-module--_sIfN\",\"width-34x\":\"width-34x--Icon-module--ZsCG_\",\"size-34x\":\"size-34x--Icon-module--g9nvi\",\"height-35x\":\"height-35x--Icon-module--MmnHQ\",\"width-35x\":\"width-35x--Icon-module--fDNdg\",\"size-35x\":\"size-35x--Icon-module--lZrEW\",\"height-36x\":\"height-36x--Icon-module--f91Vh\",\"width-36x\":\"width-36x--Icon-module--MWoLY\",\"size-36x\":\"size-36x--Icon-module--BZ4xq\",\"height-37x\":\"height-37x--Icon-module--vuZaO\",\"width-37x\":\"width-37x--Icon-module--YpAIL\",\"size-37x\":\"size-37x--Icon-module--pXXeB\",\"height-38x\":\"height-38x--Icon-module--ry2vF\",\"width-38x\":\"width-38x--Icon-module--QXlFw\",\"size-38x\":\"size-38x--Icon-module--QJU2T\",\"height-39x\":\"height-39x--Icon-module--hKajM\",\"width-39x\":\"width-39x--Icon-module--ChRMQ\",\"size-39x\":\"size-39x--Icon-module--ma5hC\",\"height-40x\":\"height-40x--Icon-module--VM51f\",\"width-40x\":\"width-40x--Icon-module--oS5DB\",\"size-40x\":\"size-40x--Icon-module--_3agY\",\"height-41x\":\"height-41x--Icon-module--dUobY\",\"width-41x\":\"width-41x--Icon-module--p77V1\",\"size-41x\":\"size-41x--Icon-module--P6AFK\",\"height-42x\":\"height-42x--Icon-module--A6Oox\",\"width-42x\":\"width-42x--Icon-module--S0Xx_\",\"size-42x\":\"size-42x--Icon-module--NGiXb\",\"height-43x\":\"height-43x--Icon-module--I1LNx\",\"width-43x\":\"width-43x--Icon-module--Tz100\",\"size-43x\":\"size-43x--Icon-module--nxzH1\",\"height-44x\":\"height-44x--Icon-module--cW58a\",\"width-44x\":\"width-44x--Icon-module--XiALy\",\"size-44x\":\"size-44x--Icon-module--nKdQ5\",\"height-45x\":\"height-45x--Icon-module--nT430\",\"width-45x\":\"width-45x--Icon-module--FNcz6\",\"size-45x\":\"size-45x--Icon-module--vur0Y\",\"height-46x\":\"height-46x--Icon-module--Aor7E\",\"width-46x\":\"width-46x--Icon-module--yJJZp\",\"size-46x\":\"size-46x--Icon-module--RTcpS\",\"height-47x\":\"height-47x--Icon-module--T1Yxm\",\"width-47x\":\"width-47x--Icon-module--gspa3\",\"size-47x\":\"size-47x--Icon-module--qpHFF\",\"height-48x\":\"height-48x--Icon-module--n4ZUK\",\"width-48x\":\"width-48x--Icon-module--SvYW6\",\"size-48x\":\"size-48x--Icon-module--QIHbM\",\"height-49x\":\"height-49x--Icon-module--RCovB\",\"width-49x\":\"width-49x--Icon-module--g9pIK\",\"size-49x\":\"size-49x--Icon-module--eF425\",\"height-50x\":\"height-50x--Icon-module--I93SY\",\"width-50x\":\"width-50x--Icon-module--I8oAZ\",\"size-50x\":\"size-50x--Icon-module--OpF8k\",\"height-51x\":\"height-51x--Icon-module--ONm5i\",\"width-51x\":\"width-51x--Icon-module--nErm6\",\"size-51x\":\"size-51x--Icon-module--yOF2h\",\"height-52x\":\"height-52x--Icon-module--dZaFh\",\"width-52x\":\"width-52x--Icon-module--rTf4i\",\"size-52x\":\"size-52x--Icon-module--oxAoC\",\"height-53x\":\"height-53x--Icon-module--s1hlh\",\"width-53x\":\"width-53x--Icon-module--kfApS\",\"size-53x\":\"size-53x--Icon-module--c2KGi\",\"height-54x\":\"height-54x--Icon-module--yBx5R\",\"width-54x\":\"width-54x--Icon-module--Fj0wT\",\"size-54x\":\"size-54x--Icon-module--V3G66\",\"height-55x\":\"height-55x--Icon-module--Ho8BA\",\"width-55x\":\"width-55x--Icon-module--Z24Cv\",\"size-55x\":\"size-55x--Icon-module--chF_S\",\"height-56x\":\"height-56x--Icon-module--TlGha\",\"width-56x\":\"width-56x--Icon-module--lF_c8\",\"size-56x\":\"size-56x--Icon-module--O6i_m\",\"height-57x\":\"height-57x--Icon-module--Iwxcf\",\"width-57x\":\"width-57x--Icon-module--Trx0v\",\"size-57x\":\"size-57x--Icon-module--JzbT_\",\"height-58x\":\"height-58x--Icon-module--DVvSx\",\"width-58x\":\"width-58x--Icon-module--XCBve\",\"size-58x\":\"size-58x--Icon-module--sUUV0\",\"height-59x\":\"height-59x--Icon-module--xmAFV\",\"width-59x\":\"width-59x--Icon-module--lBnYQ\",\"size-59x\":\"size-59x--Icon-module--iqlUX\",\"height-60x\":\"height-60x--Icon-module--fb2hW\",\"width-60x\":\"width-60x--Icon-module--Y23ti\",\"size-60x\":\"size-60x--Icon-module--rhzMk\",\"height-61x\":\"height-61x--Icon-module--SP4Zv\",\"width-61x\":\"width-61x--Icon-module--l_1ka\",\"size-61x\":\"size-61x--Icon-module--FwCAj\",\"height-62x\":\"height-62x--Icon-module--iEQuz\",\"width-62x\":\"width-62x--Icon-module--kHGZR\",\"size-62x\":\"size-62x--Icon-module--FbSqq\",\"height-63x\":\"height-63x--Icon-module--f0k04\",\"width-63x\":\"width-63x--Icon-module--P2cLa\",\"size-63x\":\"size-63x--Icon-module--uGmq7\",\"height-64x\":\"height-64x--Icon-module--Klp9y\",\"width-64x\":\"width-64x--Icon-module--lSVRM\",\"size-64x\":\"size-64x--Icon-module--j7X3r\",\"height-65x\":\"height-65x--Icon-module--v0dhF\",\"width-65x\":\"width-65x--Icon-module--J29Uz\",\"size-65x\":\"size-65x--Icon-module--hrCfX\",\"height-66x\":\"height-66x--Icon-module--Kpv99\",\"width-66x\":\"width-66x--Icon-module--BVGt8\",\"size-66x\":\"size-66x--Icon-module--XiFVB\",\"height-67x\":\"height-67x--Icon-module--SGzWZ\",\"width-67x\":\"width-67x--Icon-module--Zsqc0\",\"size-67x\":\"size-67x--Icon-module--xad7D\",\"height-68x\":\"height-68x--Icon-module--IE2eY\",\"width-68x\":\"width-68x--Icon-module--wqBwt\",\"size-68x\":\"size-68x--Icon-module--xQ0GN\",\"height-69x\":\"height-69x--Icon-module--M1fvs\",\"width-69x\":\"width-69x--Icon-module--b0mxO\",\"size-69x\":\"size-69x--Icon-module--j9gaL\",\"height-70x\":\"height-70x--Icon-module--UAJcc\",\"width-70x\":\"width-70x--Icon-module--vSCOz\",\"size-70x\":\"size-70x--Icon-module--n6FO3\",\"height-71x\":\"height-71x--Icon-module--_S5Uo\",\"width-71x\":\"width-71x--Icon-module--eH58Z\",\"size-71x\":\"size-71x--Icon-module--s3Nad\",\"height-72x\":\"height-72x--Icon-module--T_bHw\",\"width-72x\":\"width-72x--Icon-module--Ox26j\",\"size-72x\":\"size-72x--Icon-module--FcKXt\",\"height-73x\":\"height-73x--Icon-module--ryxlQ\",\"width-73x\":\"width-73x--Icon-module--DGb79\",\"size-73x\":\"size-73x--Icon-module--c8CzU\",\"height-74x\":\"height-74x--Icon-module--JiqDT\",\"width-74x\":\"width-74x--Icon-module--VrUW5\",\"size-74x\":\"size-74x--Icon-module--km2Fl\",\"height-75x\":\"height-75x--Icon-module--Yxvwi\",\"width-75x\":\"width-75x--Icon-module--YZWmm\",\"size-75x\":\"size-75x--Icon-module--s4Kjd\",\"height-76x\":\"height-76x--Icon-module--SonI8\",\"width-76x\":\"width-76x--Icon-module--hsUK5\",\"size-76x\":\"size-76x--Icon-module--McOII\",\"height-77x\":\"height-77x--Icon-module--yAdLG\",\"width-77x\":\"width-77x--Icon-module--RgSzL\",\"size-77x\":\"size-77x--Icon-module--XOUao\",\"height-78x\":\"height-78x--Icon-module--sAYK3\",\"width-78x\":\"width-78x--Icon-module--c6W6G\",\"size-78x\":\"size-78x--Icon-module--dz7gD\",\"height-79x\":\"height-79x--Icon-module--dUrmH\",\"width-79x\":\"width-79x--Icon-module--C6zLh\",\"size-79x\":\"size-79x--Icon-module--OYrO7\",\"height-80x\":\"height-80x--Icon-module--YYfTd\",\"width-80x\":\"width-80x--Icon-module--PKCkK\",\"size-80x\":\"size-80x--Icon-module--iXL4u\",\"height-81x\":\"height-81x--Icon-module--nPwkr\",\"width-81x\":\"width-81x--Icon-module--y5S8z\",\"size-81x\":\"size-81x--Icon-module--IowPL\",\"height-82x\":\"height-82x--Icon-module--i33wi\",\"width-82x\":\"width-82x--Icon-module--h30s2\",\"size-82x\":\"size-82x--Icon-module--wwqbf\",\"height-83x\":\"height-83x--Icon-module--OWGDo\",\"width-83x\":\"width-83x--Icon-module--gFvaY\",\"size-83x\":\"size-83x--Icon-module--JSrkV\",\"height-84x\":\"height-84x--Icon-module--Wd2Pq\",\"width-84x\":\"width-84x--Icon-module--Gw8vW\",\"size-84x\":\"size-84x--Icon-module--Ktzck\",\"height-85x\":\"height-85x--Icon-module--EM0Cs\",\"width-85x\":\"width-85x--Icon-module--z3QlU\",\"size-85x\":\"size-85x--Icon-module--FIfej\",\"height-86x\":\"height-86x--Icon-module--VO9zg\",\"width-86x\":\"width-86x--Icon-module--ZLGkH\",\"size-86x\":\"size-86x--Icon-module--vuezb\",\"height-87x\":\"height-87x--Icon-module--ubJ25\",\"width-87x\":\"width-87x--Icon-module--ogKCd\",\"size-87x\":\"size-87x--Icon-module--iWYc1\",\"height-88x\":\"height-88x--Icon-module--J4s5z\",\"width-88x\":\"width-88x--Icon-module--ZX9ov\",\"size-88x\":\"size-88x--Icon-module--zf6Id\",\"height-89x\":\"height-89x--Icon-module--dt2o3\",\"width-89x\":\"width-89x--Icon-module--rso6m\",\"size-89x\":\"size-89x--Icon-module--T1Xsl\",\"height-90x\":\"height-90x--Icon-module--ED9sS\",\"width-90x\":\"width-90x--Icon-module--uJpju\",\"size-90x\":\"size-90x--Icon-module--bLnWU\",\"height-91x\":\"height-91x--Icon-module--FWVma\",\"width-91x\":\"width-91x--Icon-module--NHM4M\",\"size-91x\":\"size-91x--Icon-module--QK1qM\",\"height-92x\":\"height-92x--Icon-module--amDSz\",\"width-92x\":\"width-92x--Icon-module--H1lXq\",\"size-92x\":\"size-92x--Icon-module--VSSQt\",\"height-93x\":\"height-93x--Icon-module--WEjnZ\",\"width-93x\":\"width-93x--Icon-module--bvkRg\",\"size-93x\":\"size-93x--Icon-module--YfbRL\",\"height-94x\":\"height-94x--Icon-module--Jx8PQ\",\"width-94x\":\"width-94x--Icon-module--UNzkX\",\"size-94x\":\"size-94x--Icon-module--aJSls\",\"height-95x\":\"height-95x--Icon-module--slr1f\",\"width-95x\":\"width-95x--Icon-module--viIKD\",\"size-95x\":\"size-95x--Icon-module--WEryx\",\"height-96x\":\"height-96x--Icon-module--dTaHl\",\"width-96x\":\"width-96x--Icon-module--MxmR5\",\"size-96x\":\"size-96x--Icon-module--SanXL\",\"height-97x\":\"height-97x--Icon-module--lDhOL\",\"width-97x\":\"width-97x--Icon-module--oqx_M\",\"size-97x\":\"size-97x--Icon-module--lgnqC\",\"height-98x\":\"height-98x--Icon-module--e8EXS\",\"width-98x\":\"width-98x--Icon-module--XpW3Q\",\"size-98x\":\"size-98x--Icon-module--vqZ5Q\",\"height-99x\":\"height-99x--Icon-module--qfENn\",\"width-99x\":\"width-99x--Icon-module--H75qd\",\"size-99x\":\"size-99x--Icon-module--v8EZC\",\"height-100x\":\"height-100x--Icon-module--UzVOV\",\"width-100x\":\"width-100x--Icon-module--OOmlx\",\"size-100x\":\"size-100x--Icon-module--hJvhx\",\"height-auto\":\"height-auto--Icon-module--EDfXh\",\"width-auto\":\"width-auto--Icon-module--MyQUQ\",\"size-auto\":\"size-auto--Icon-module--bQ2dD\",\"height-half\":\"height-half--Icon-module--S9lHd\",\"width-half\":\"width-half--Icon-module--XBYoc\",\"size-half\":\"size-half--Icon-module--R4oC9\",\"height-full\":\"height-full--Icon-module--NUvst\",\"width-full\":\"width-full--Icon-module--xW1Ci\",\"size-full\":\"size-full--Icon-module--acFci\",\"height-fit-content\":\"height-fit-content--Icon-module--JveLv\",\"width-fit-content\":\"width-fit-content--Icon-module--FGUiE\",\"size-fit-content\":\"size-fit-content--Icon-module--_XAQp\",\"height-max-content\":\"height-max-content--Icon-module--nmqQp\",\"width-max-content\":\"width-max-content--Icon-module--to5uQ\",\"size-max-content\":\"size-max-content--Icon-module--dd7Pq\",\"stroke-eggplant\":\"stroke-eggplant--Icon-module--PHE4p\",\"fill-eggplant\":\"fill-eggplant--Icon-module--MOBTd\",\"stroke-eggplant_light\":\"stroke-eggplant_light--Icon-module--QuJqd\",\"fill-eggplant_light\":\"fill-eggplant_light--Icon-module--pQuxv\",\"stroke-red\":\"stroke-red--Icon-module--LvOrT\",\"fill-red\":\"fill-red--Icon-module--JOtK7\",\"stroke-red_dark\":\"stroke-red_dark--Icon-module--hRGfF\",\"fill-red_dark\":\"fill-red_dark--Icon-module--YYpoZ\",\"stroke-yellow\":\"stroke-yellow--Icon-module--GeLJS\",\"fill-yellow\":\"fill-yellow--Icon-module--FcyzK\",\"stroke-yellow_darker\":\"stroke-yellow_darker--Icon-module--aXfmX\",\"fill-yellow_darker\":\"fill-yellow_darker--Icon-module--ivuxK\",\"stroke-black\":\"stroke-black--Icon-module--JCIG1\",\"fill-black\":\"fill-black--Icon-module--TcYUl\",\"stroke-gray\":\"stroke-gray--Icon-module--KB44u\",\"fill-gray\":\"fill-gray--Icon-module--z3Cno\",\"stroke-green\":\"stroke-green--Icon-module--a_smc\",\"fill-green\":\"fill-green--Icon-module--TEEY0\",\"stroke-blue\":\"stroke-blue--Icon-module--YNjCP\",\"fill-blue\":\"fill-blue--Icon-module--j7X38\",\"stroke-blue_dark\":\"stroke-blue_dark--Icon-module--PEBSP\",\"fill-blue_dark\":\"fill-blue_dark--Icon-module--BtIKB\",\"stroke-blue_darker\":\"stroke-blue_darker--Icon-module--hecYA\",\"fill-blue_darker\":\"fill-blue_darker--Icon-module--DyaOZ\",\"stroke-white\":\"stroke-white--Icon-module--MmhPg\",\"fill-white\":\"fill-white--Icon-module--xU9pO\",\"stroke-transparent\":\"stroke-transparent--Icon-module--xX9ux\",\"fill-transparent\":\"fill-transparent--Icon-module--dYsIO\",\"stroke-tertiary-darker\":\"stroke-tertiary-darker--Icon-module--MLo5O\",\"fill-tertiary-darker\":\"fill-tertiary-darker--Icon-module--Geik4\",\"rotate-top\":\"rotate-top--Icon-module--OJF0s\",\"rotate-right\":\"rotate-right--Icon-module--sFcPe\",\"rotate-bottom\":\"rotate-bottom--Icon-module--cqnK3\",\"rotate-left\":\"rotate-left--Icon-module--TWY8r\"};","import { baseSizeList, getMargin } from \"@base/components/common/primitives/BaseElement\";\nimport clsx from \"clsx\";\nimport React, { HTMLAttributes, useEffect, useRef, useState } from \"react\";\nimport styles from \"./Icon.module.scss\";\ntype colors =\n\t| \"eggplant\"\n\t| \"eggplant_light\"\n\t| \"red\"\n\t| \"red_dark\"\n\t| \"black\"\n\t| \"gray\"\n\t| \"green\"\n\t| \"yellow\"\n\t| \"yellow_darker\"\n\t| \"blue\"\n\t| \"blue_dark\"\n\t| \"white\"\n\t| \"transparent\"\n\t| \"tertiary-darker\";\nexport type rotation = \"top\" | \"bottom\" | \"left\" | \"right\";\n\nexport interface IconProps extends HTMLAttributes<HTMLElement> {\n\tsource: string;\n\tfillcolor?: colors;\n\tstrokecolor?: colors;\n\tsize?: baseSizeList;\n\twidth?: baseSizeList;\n\theight?: baseSizeList;\n\trotate?: rotation;\n\tclassName?: string;\n\tmargin?: Array<baseSizeList> | baseSizeList;\n\tmarginTop?: baseSizeList;\n\tmarginBottom?: baseSizeList;\n\tmarginLeft?: baseSizeList;\n\tmarginRight?: baseSizeList;\n}\n\nexport const Icon = React.forwardRef<HTMLDivElement, IconProps>(\n\t(\n\t\t{\n\t\t\tsource,\n\t\t\tfillcolor,\n\t\t\tstrokecolor,\n\t\t\twidth,\n\t\t\theight,\n\t\t\tsize,\n\t\t\trotate,\n\t\t\tclassName,\n\t\t\tmargin,\n\t\t\tmarginTop,\n\t\t\tmarginBottom,\n\t\t\tmarginLeft,\n\t\t\tmarginRight,\n\t\t\t...props\n\t\t}: IconProps,\n\t\tforwardedRef\n\t) => {\n\t\tconst [iconSrc, setIconSrc] = useState(null);\n\t\tconst internalRef = useRef(null);\n\n\t\t// Sync internal ref with forwarded ref\n\t\tuseEffect(() => {\n\t\t\tif (!forwardedRef) return;\n\t\t\tif (typeof forwardedRef === \"function\") {\n\t\t\t\tforwardedRef(internalRef.current);\n\t\t\t} else {\n\t\t\t\tforwardedRef.current = internalRef.current;\n\t\t\t}\n\t\t}, [forwardedRef]);\n\n\t\tuseEffect(() => {\n\t\t\tfetchData();\n\t\t}, [source]);\n\n\t\tconst contentRef = internalRef;\n\n\t\tconst cssClasses = clsx([\n\t\t\tstyles.icon,\n\t\t\tfillcolor && styles[`fill-${fillcolor}`],\n\t\t\tstrokecolor && styles[`stroke-${strokecolor}`],\n\t\t\tsize && styles[`size-${size}`],\n\t\t\twidth && styles[`width-${width}`],\n\t\t\theight && styles[`height-${height}`],\n\t\t\trotate && styles[`rotate-${rotate}`],\n\t\t\tmargin && getMargin(margin),\n\t\t\tmarginTop && `margin-top-${marginTop}`,\n\t\t\tmarginBottom && `margin-bottom-${marginBottom}`,\n\t\t\tmarginLeft && `margin-left-${marginLeft}`,\n\t\t\tmarginRight && `margin-right-${marginRight}`,\n\t\t\tclassName,\n\t\t]);\n\n\t\tconst loadIcon = (iconSrc) => {\n\t\t\tif (window.react?.iconCache?.[iconSrc]) {\n\t\t\t\treturn Promise.resolve(window.react.iconCache[iconSrc]);\n\t\t\t} else if (window.react?.iconPromiseCache?.[iconSrc]) {\n\t\t\t\treturn window.react.iconPromiseCache[iconSrc];\n\t\t\t} else {\n\t\t\t\tconst iconPromise = fetch(iconSrc)\n\t\t\t\t\t.then((response) => {\n\t\t\t\t\t\tif (\n\t\t\t\t\t\t\tresponse.status === 200 &&\n\t\t\t\t\t\t\tresponse.headers.get(\"content-type\").startsWith(\"image/svg+xml\")\n\t\t\t\t\t\t) {\n\t\t\t\t\t\t\treturn response.text();\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn Promise.reject(response);\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t\t\t.then((iconContent) => {\n\t\t\t\t\t\twindow.react.iconCache[iconSrc] = iconContent;\n\t\t\t\t\t\tdelete window.react.iconPromiseCache[iconSrc];\n\t\t\t\t\t\treturn iconContent;\n\t\t\t\t\t});\n\n\t\t\t\twindow.react.iconPromiseCache[iconSrc] = iconPromise;\n\t\t\t\treturn iconPromise;\n\t\t\t}\n\t\t};\n\n\t\tconst fetchData = () => {\n\t\t\tif (!contentRef.current) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (source) {\n\t\t\t\tif (iconSrc !== source) {\n\t\t\t\t\tsetIconSrc(source);\n\t\t\t\t\tconst fetchSrc = source;\n\t\t\t\t\tcontentRef.current.innerHTML = \"\";\n\t\t\t\t\tloadIcon(source)\n\t\t\t\t\t\t.then((imgContent) => {\n\t\t\t\t\t\t\tif (fetchSrc === source && contentRef.current) {\n\t\t\t\t\t\t\t\tcontentRef.current.innerHTML = imgContent;\n\t\t\t\t\t\t\t\tconst fileName = fetchSrc\n\t\t\t\t\t\t\t\t\t.split(/(\\\\|\\/)/g)\n\t\t\t\t\t\t\t\t\t.pop()\n\t\t\t\t\t\t\t\t\t.replace(\".svg\", \"\");\n\t\t\t\t\t\t\t\tif (fileName) {\n\t\t\t\t\t\t\t\t\tcontentRef.current.classList.add(fileName);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t})\n\t\t\t\t\t\t.catch((response) => {\n\t\t\t\t\t\t\tconsole.error(response);\n\t\t\t\t\t\t\tif (contentRef.current) {\n\t\t\t\t\t\t\t\tcontentRef.current.innerHTML = \"❌\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcontentRef.current.innerHTML = \"❌\";\n\t\t\t}\n\t\t};\n\n\t\treturn <div {...props} className={cssClasses} ref={contentRef}></div>;\n\t}\n);\n\nIcon.displayName = \"Icon\";\n","import { useToast } from \"@base/components/common/Toast\";\nimport ReconnectingEventSource from \"reconnecting-eventsource\";\nimport { getAppContext, useAppConfig } from \"./CakeStore\";\nimport { PlatformVersionDocument } from \"@base/core/graphql\";\nimport { useOrgStore } from \"@base/hooks/useOrgStore\";\n\ntype ServerSentEventCallback = (Object) => void;\nconst { ToastError, ToastSuccess } = useToast();\n\nclass ReconnectingEventSourceWithTimeout extends ReconnectingEventSource {\n\t#retryCount: number = 0;\n\t#minRetryTime: number = 5000;\n\t#jitterTime: number = 3000;\n\tstatic MAX_RETRIES = 10; // After ~1 minute stop trying\n\n\t_onerror(event: Event) {\n\t\tif (this.readyState === 1) {\n\t\t\tthis.readyState = 0;\n\t\t\tthis.onerror(event);\n\t\t} else {\n\t\t\tthis.#retryCount += 1;\n\t\t\tconsole.debug(`SSE connection error (retry ${this.#retryCount}) ${new Date().toISOString()}`, event);\n\t\t\tif (this.#retryCount >= ReconnectingEventSourceWithTimeout.MAX_RETRIES) {\n\t\t\t\tconsole.error(\"Maximum SSE retry attempts reached, closing connection.\");\n\t\t\t\tToastError(\"Could not connect to the server. Please refresh\", Infinity);\n\t\t\t\tthis._eventSource.close();\n\t\t\t\tthis._eventSource = null;\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\n\t\tif (this._eventSource) {\n\t\t\tif (this._eventSource.readyState === 2) {\n\t\t\t\t// reconnect with new object\n\t\t\t\tthis._eventSource.close();\n\t\t\t\tthis._eventSource = null;\n\n\t\t\t\t// reconnect after random timeout < max_retry_time\n\t\t\t\tconst timeout = Math.round(this.#minRetryTime + Math.random() * this.#jitterTime);\n\t\t\t\tthis._timer = setTimeout(() => this._start(), timeout);\n\t\t\t}\n\t\t}\n\t}\n\n\t_onopen(event: Event): void {\n\t\tconsole.debug(\"SSE connection opened\", event, this._eventSource);\n\t\tthis.#retryCount = 0;\n\t\tsuper._onopen(event);\n\t}\n}\n\nclass ServerSentEvents {\n\t#privateEvents?: ReconnectingEventSourceWithTimeout = undefined;\n\t#listeners: Array<ServerSentEventCallback> = [];\n\t#skipSseOrgCheck: boolean = false;\n\n\tpublic addListener = (listener: ServerSentEventCallback) => {\n\t\tthis.#listeners.push(listener);\n\t\treturn () => this.removeListener(listener);\n\t};\n\n\tpublic removeListener = (listener: ServerSentEventCallback) => {\n\t\tthis.#listeners = this.#listeners.filter((l) => l !== listener);\n\t};\n\n\t#onEvent = (e: MessageEvent) => {\n\t\tconsole.debug(\"SSE event received\", e.data);\n\t\ttry {\n\t\t\tconst event = JSON.parse(e.data);\n\t\t\tconsole.debug(\"event received\", event);\n\t\t\tif (event.error) {\n\t\t\t\tToastError(event.error[\"message\"] || \"Unknown error\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (event.success) {\n\t\t\t\tToastSuccess(event.success[\"message\"]);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (!this.#skipSseOrgCheck) {\n\t\t\t\tconst organisationId =\n\t\t\t\t\tuseOrgStore.getState().selectedOrgId ?? getAppContext()?.DEFAULT_SELECTED_COMPANY_ID;\n\t\t\t\tif ((event.organisation_id || organisationId) != organisationId) {\n\t\t\t\t\tconsole.debug(\"Ignoring event from other organisation\");\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.#listeners.forEach((l) => l(event));\n\t\t} catch (err) {\n\t\t\tconsole.warn(\"failed to trigger server-side event\", err, e.data);\n\t\t}\n\t};\n\n\t#onStreamError = (e: MessageEvent) => {\n\t\t// ... client fell behind, reinitialize ...\n\t\tconsole.debug(\"stream-reset\", e);\n\t};\n\n\t#onOpen = () => {\n\t\tconsole.log(\"onOpen - checking platform version\");\n\t\tuseAppConfig\n\t\t\t.getState()\n\t\t\t?.apolloClient?.query({ query: PlatformVersionDocument })\n\t\t\t.then((response) => {\n\t\t\t\tif (!response.errors) {\n\t\t\t\t\tif (\n\t\t\t\t\t\t!window.cakeUpdateAvailable &&\n\t\t\t\t\t\tresponse.data.platformVersion !== (getAppContext()?.PLATFORM_VERSION || \"\")\n\t\t\t\t\t) {\n\t\t\t\t\t\twindow.cakeUpdateAvailable = true;\n\t\t\t\t\t\twindow.riot?.update();\n\t\t\t\t\t}\n\t\t\t\t\treturn;\n\t\t\t\t} else {\n\t\t\t\t\treturn Promise.reject(response);\n\t\t\t\t}\n\t\t\t})\n\t\t\t.catch(console.error);\n\t};\n\n\tpublic initialize = (userId: string, skipSseOrgCheck: boolean = false) => {\n\t\tthis.#destroy();\n\n\t\t// Private per-user events\n\t\tthis.#privateEvents = new ReconnectingEventSourceWithTimeout(`/sse/u/${userId}/`);\n\t\tthis.#privateEvents.onopen = this.#onOpen;\n\t\tthis.#privateEvents.onerror = this.#onStreamError;\n\t\tthis.#privateEvents.onmessage = this.#onEvent;\n\t\tthis.#skipSseOrgCheck = skipSseOrgCheck;\n\t};\n\n\t#destroy = () => {\n\t\tif (this.#privateEvents) {\n\t\t\tthis.#privateEvents.close();\n\t\t\tthis.#privateEvents = undefined;\n\t\t}\n\t};\n}\n\nexport { ServerSentEvents };\n","// reactCompat.ts\nimport { useToast } from \"@base/components/common/Toast\";\nimport { ServerSentEvents } from \"@base/core/ServerSentEvents\";\nimport { translate } from \"@founder/utils/translate\";\nimport mitt from \"mitt\";\nimport { useEffect, useRef } from \"react\";\nimport { create } from \"zustand\";\nimport { useShallow } from \"zustand/shallow\";\n\ntype InternalEventPayloads = {\n\torganisation_added?: unknown;\n\torganisation_changed?: unknown;\n\torganisation_info_changed?: unknown;\n\tavatar_changed?: unknown;\n\tinvestor_change_to_details?: unknown;\n\troute_changed?: unknown;\n\tupgrade_plan_error?: unknown;\n\tchecklist_updated?: unknown;\n\tmessage_changed?: unknown;\n\tsignature_changed?: unknown;\n};\n\ntype SseEventPayloads = {\n\torganisation_deleted?: unknown;\n\tdocument_sign_change?: unknown;\n\traise_offer_changed?: unknown;\n\tshares_issued?: unknown;\n\tlicense_updated?: unknown;\n\thistorical_409a_changed?: unknown;\n\tvaluation_visibility_settings_updated?: unknown;\n\tuser_access_updated?: unknown;\n\tcommand_center_update?: unknown;\n\tshare_transfer_offers_changed?: unknown;\n\ttransfer_round_changed?: unknown;\n\tshare_certificate_generated?: unknown;\n\traise_changed?: unknown;\n\ttransfer_offer_offer_changed?: unknown;\n\ttransfer_offer_offer_added?: unknown;\n\tannouncement_sent?: unknown;\n\tmessage_saved?: unknown;\n\tallow_replies_toggled?: unknown;\n\tnote_deleted?: unknown;\n\tnote_changed?: unknown;\n\trequest_exercise_settings_changed?: unknown;\n\trequest_exercise_changed?: unknown;\n\tboard_approval_changed?: unknown;\n\toffboarding_changed?: unknown;\n\tscanbot_changed?: unknown;\n\tstakeholders_deleted?: unknown;\n\tstakeholders_invited?: unknown;\n\tqsbs_report_generated?: unknown;\n\troute_changed?: unknown;\n\torganisation_info_changed?: unknown;\n    organisation_added?: unknown;\n    organisation_changed?: unknown;\n    avatar_changed?: unknown;\n\t// BULK\n\tbulk_upload_transactions?: unknown;\n\tbulk_upload_esop_offers?: unknown;\n\tbulk_upload_ess_offers?: unknown;\n\tbulk_upload_rsu_offers?: unknown;\n\tbulk_upload_shareholders?: unknown;\n\tbulk_upload_notes?: unknown;\n\tbulk_delete_transactions?: unknown;\n\t// ESOP\n\tesop_added?: unknown;\n\tesop_changed?: unknown;\n\tesop_deleted?: unknown;\n\tesop_group_added?: unknown;\n\tesop_group_changed?: unknown;\n\tesop_group_deleted?: unknown;\n\tesop_offer_added?: unknown;\n\tesop_offer_changed?: unknown;\n\tesop_offers_changed?: unknown;\n\tesop_offer_deleted?: unknown;\n\t// ESS\n\tess_added?: unknown;\n\tess_changed?: unknown;\n\tess_deleted?: unknown;\n\tess_group_added?: unknown;\n\tess_group_changed?: unknown;\n\tess_group_deleted?: unknown;\n\tess_offer_added?: unknown;\n\tess_offer_changed?: unknown;\n\tess_offer_deleted?: unknown;\n\t// Foundervesting\n\tfoundervesting_added?: unknown;\n\tfoundervesting_changed?: unknown;\n\tfoundervesting_deleted?: unknown;\n\tfoundervesting_group_added?: unknown;\n\tfoundervesting_group_changed?: unknown;\n\tfoundervesting_group_deleted?: unknown;\n\tfoundervesting_offer_added?: unknown;\n\tfoundervesting_offer_changed?: unknown;\n\tfoundervesting_offer_deleted?: unknown;\n\t// RSU\n\trsu_added?: unknown;\n\trsu_changed?: unknown;\n\trsu_deleted?: unknown;\n\trsu_group_added?: unknown;\n\trsu_group_changed?: unknown;\n\trsu_group_deleted?: unknown;\n\trsu_offer_added?: unknown;\n\trsu_offer_changed?: unknown;\n\trsu_offer_deleted?: unknown;\n\t// WARRANT\n\twarrant_changed?: unknown;\n\twarrant_offer_added?: unknown;\n\twarrant_offer_changed?: unknown;\n\twarrant_offer_deleted?: unknown;\n\tbulk_upload_warrant_offers?: unknown;\n};\n\ntype CakeEventPayloads = SseEventPayloads & InternalEventPayloads;\n\ninterface SseState {\n\tsse: ServerSentEvents;\n\teventPayloads: SseEventPayloads;\n\tsetEvent: (eventName: keyof CakeEventPayloads, payload?: unknown) => void;\n}\n\nconst useServerSentEventsStore = create<SseState>((set) => {\n\tconst setEvent = (eventName, payload) => {\n\t\tset((state) => ({\n\t\t\t...state,\n\t\t\teventPayloads: {\n\t\t\t\t...state.eventPayloads,\n\t\t\t\t[eventName]: payload,\n\t\t\t},\n\t\t}));\n\t\t_handleEventInternal(eventName, payload || {});\n\t};\n\n\tconst sse = new ServerSentEvents();\n\tsse.addListener((event) => {\n\t\tconst eventName = Object.keys(event)[0] as keyof SseEventPayloads;\n\t\tconst payload = event[eventName];\n\t\tsetEvent(eventName, payload);\n\t});\n\treturn { sse, eventPayloads: {}, setEvent };\n});\n\nconst emitter = mitt<CakeEventPayloads>();\n\nconst useServerSentEvents = <K extends (keyof SseEventPayloads)[]>(\n\teffect: (eventName: K[number], payload: SseEventPayloads[K[number]]) => void,\n\teventKeys: K\n) => {\n\tconst isMounted = useRef(false);\n\tconst selectedPayloads = useServerSentEventsStore(\n\t\tuseShallow((state) => eventKeys.map((key) => state.eventPayloads[key]))\n\t);\n\n\tconst previousPayloadsRef = useRef<SseEventPayloads[K[number]][]>([]);\n\n\tuseEffect(() => {\n\t\tif (!isMounted.current) {\n\t\t\tisMounted.current = true;\n\t\t\tpreviousPayloadsRef.current = selectedPayloads;\n\t\t\treturn;\n\t\t}\n\n\t\tfor (let i = 0; i < selectedPayloads.length; i++) {\n\t\t\tconst payload = selectedPayloads[i];\n\t\t\tconst eventName = eventKeys[i];\n\t\t\tif (selectedPayloads[i] !== previousPayloadsRef.current[i]) {\n\t\t\t\teffect(eventName, payload);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tpreviousPayloadsRef.current = selectedPayloads;\n\t}, [selectedPayloads, effect, eventKeys]);\n};\n\nfunction setupObserver(\n\teventName: keyof CakeEventPayloads,\n\triotThis: { on: (...args) => void },\n\tcallback: (payload: unknown) => void\n) {\n\tif (!callback || !riotThis) {\n\t\tconsole.warn(\"Invalid setupObserver call\");\n\t\treturn;\n\t}\n\temitter.on(eventName, callback);\n\triotThis.on(\"before-unmount\", () => {\n\t\temitter.off(eventName, callback);\n\t});\n}\n\nlet orgChangeDebounceCb: NodeJS.Timeout | null = null;\nconst DEBOUNCE_PERIOD_MS = 300;\nconst _handleEventInternal = (eventName: keyof CakeEventPayloads, payload: object) => {\n\tconst { ToastSuccess } = useToast();\n\tswitch (eventName) {\n\t\tcase \"organisation_changed\": {\n\t\t\tif (orgChangeDebounceCb) {\n\t\t\t\tclearTimeout(orgChangeDebounceCb);\n\t\t\t\torgChangeDebounceCb = null;\n\t\t\t}\n\t\t\torgChangeDebounceCb = setTimeout(() => emitter.emit(eventName, payload), DEBOUNCE_PERIOD_MS);\n\t\t\tbreak;\n\t\t}\n\t\tcase \"bulk_upload_transactions\": {\n\t\t\tif (!payload[\"count\"]) {\n\t\t\t\tconsole.error(\"Event without bulk count\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tToastSuccess(`Successfully imported ${payload[\"count\"]} ${translate(\"shareholders\")}!`);\n\t\t\temitter.emit(\"shares_issued\", payload); // legacy behaviour\n\t\t\tbreak;\n\t\t}\n\t\tcase \"bulk_upload_esop_offers\": {\n\t\t\tif (!payload[\"count\"]) {\n\t\t\t\tconsole.error(\"Event without bulk count\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (!payload[\"esop_id\"]) {\n\t\t\t\tconsole.error(\"Event without ESOP ID\");\n\t\t\t}\n\t\t\tToastSuccess(`Successfully imported ${payload[\"count\"]} ESOP offers!`);\n\t\t\temitter.emit(\"esop_offer_added\", payload[\"esop_id\"]); // legacy behaviour\n\t\t\tbreak;\n\t\t}\n\t\tcase \"bulk_upload_ess_offers\": {\n\t\t\tif (!payload[\"count\"]) {\n\t\t\t\tconsole.error(\"Event without bulk count\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (!payload[\"ess_id\"]) {\n\t\t\t\tconsole.error(\"Event without ESS ID\");\n\t\t\t}\n\t\t\tToastSuccess(`Successfully imported ${payload[\"count\"]} ESS offers!`);\n\t\t\temitter.emit(\"ess_offer_added\", payload[\"ess_id\"]); // legacy behaviour\n\t\t\tbreak;\n\t\t}\n\t\tcase \"bulk_upload_rsu_offers\": {\n\t\t\tif (!payload[\"count\"]) {\n\t\t\t\tconsole.error(\"Event without bulk count\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (!payload[\"rsu_id\"]) {\n\t\t\t\tconsole.error(\"Event without RSU ID\");\n\t\t\t}\n\t\t\tToastSuccess(`Successfully imported ${payload[\"count\"]} RSU offers!`);\n\t\t\temitter.emit(\"rsu_offer_added\", payload[\"rsu_id\"]); // legacy behaviour\n\t\t\tbreak;\n\t\t}\n\t\tcase \"bulk_upload_shareholders\": {\n\t\t\tif (!payload[\"count\"]) {\n\t\t\t\tconsole.error(\"Event without bulk count\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tToastSuccess(`Successfully imported ${payload[\"count\"]} ${translate(\"shareholders\")}!`);\n\t\t\temitter.emit(\"organisation_changed\"); // legacy behaviour\n\t\t\tbreak;\n\t\t}\n\t\tcase \"bulk_upload_notes\": {\n\t\t\tif (!payload[\"count\"]) {\n\t\t\t\tconsole.error(\"Event without bulk count\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tToastSuccess(`Successfully imported ${payload[\"count\"]} notes!`);\n\t\t\temitter.emit(\"organisation_changed\"); // legacy behaviour\n\t\t\tbreak;\n\t\t}\n\t\tcase \"bulk_delete_transactions\": {\n\t\t\tif (!payload[\"count\"]) {\n\t\t\t\tconsole.error(\"Event without bulk count\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tToastSuccess(`Successfully deleted ${payload[\"count\"]} transactions!`);\n\t\t\temitter.emit(\"organisation_changed\"); // legacy behaviour\n\t\t\tbreak;\n\t\t}\n\t\tcase \"esop_offers_changed\": {\n\t\t\tif (!payload[\"count\"]) {\n\t\t\t\tconsole.error(\"Event without bulk count\");\n\t\t\t\treturn;\n\t\t\t}\n\t\t\temitter.emit(\"esop_offer_changed\"); // legacy behaviour\n\t\t\tbreak;\n\t\t}\n\t\tcase \"share_certificate_generated\": {\n\t\t\tconst isLast = payload[\"remaining\"] == 0;\n\t\t\tif (isLast) {\n\t\t\t\t// TODO: translate needs to be in the base app\n\t\t\t\tToastSuccess(`${translate(\"Share certificate\")} issuing complete!`);\n\t\t\t}\n\t\t\tdelete payload[\"remaining\"];\n\t\t}\n\t\tdefault: {\n\t\t\t// console.debug(`Internal event triggered: ${eventName}`, payload);\n\t\t\temitter.emit(eventName, payload);\n\t\t}\n\t}\n};\n\nconst triggerInternalEvent = (eventName: keyof CakeEventPayloads, payload?: unknown) =>\n\tuseServerSentEventsStore.getState().setEvent(eventName, payload);\n\nexport { setupObserver, triggerInternalEvent, useServerSentEvents, useServerSentEventsStore };\n","import clsx from \"clsx\";\nimport React, { HTMLAttributes } from \"react\";\n\nexport type baseSizeList =\n\t| \"0\"\n\t| \"025x\"\n\t| \"05x\"\n\t| \"1x\"\n\t| \"2x\"\n\t| \"3x\"\n\t| \"4x\"\n\t| \"5x\"\n\t| \"6x\"\n\t| \"7x\"\n\t| \"8x\"\n\t| \"9x\"\n\t| \"10x\"\n\t| \"11x\"\n\t| \"12x\"\n\t| \"13x\"\n\t| \"14x\"\n\t| \"15x\"\n\t| \"16x\"\n\t| \"17x\"\n\t| \"18x\"\n\t| \"19x\"\n\t| \"20x\"\n\t| \"21x\"\n\t| \"22x\"\n\t| \"23x\"\n\t| \"24x\"\n\t| \"25x\"\n\t| \"26x\"\n\t| \"27x\"\n\t| \"28x\"\n\t| \"29x\"\n\t| \"30x\"\n\t| \"31x\"\n\t| \"32x\"\n\t| \"33x\"\n\t| \"34x\"\n\t| \"35x\"\n\t| \"36x\"\n\t| \"37x\"\n\t| \"38x\"\n\t| \"39x\"\n\t| \"40x\"\n\t| \"41x\"\n\t| \"42x\"\n\t| \"43x\"\n\t| \"44x\"\n\t| \"45x\"\n\t| \"46x\"\n\t| \"47x\"\n\t| \"48x\"\n\t| \"49x\"\n\t| \"50x\"\n\t| \"51x\"\n\t| \"52x\"\n\t| \"53x\"\n\t| \"54x\"\n\t| \"55x\"\n\t| \"56x\"\n\t| \"57x\"\n\t| \"58x\"\n\t| \"59x\"\n\t| \"60x\"\n\t| \"92x\"\n\t| \"full\"\n\t| \"half\"\n\t| \"max-content\"\n\t| \"fit-content\"\n\t| \"auto\";\n\nexport type baseSizes =\n\t| \"full\"\n\t| \"minimal\"\n\t| \"full-width\"\n\t| \"full-height\"\n\t| \"half-width\"\n\t| \"half-height\"\n\t| \"minimal-width\"\n\t| \"minimal-height\"\n\t| \"small\"\n\t| \"regular\"\n\t| \"big\";\n\nexport interface DefaultProps {\n\tclassName?: string;\n\tmargin?: Array<baseSizeList> | baseSizeList;\n\tmarginTop?: baseSizeList;\n\tmarginBottom?: baseSizeList;\n\tmarginLeft?: baseSizeList;\n\tmarginRight?: baseSizeList;\n\tpadding?: Array<baseSizeList> | baseSizeList;\n\tpaddingTop?: baseSizeList;\n\tpaddingBottom?: baseSizeList;\n\tpaddingLeft?: baseSizeList;\n\tpaddingRight?: baseSizeList;\n\theight?: baseSizeList;\n\twidth?: baseSizeList;\n\tsize?: Array<baseSizes> | baseSizes;\n\tchildren?: React.ReactNode;\n\tbackground?:\n\t\t| \"primary\"\n\t\t| \"primary-darker\"\n\t\t| \"primary-lighter\"\n\t\t| \"primary-lightest\"\n\t\t| \"secondary\"\n\t\t| \"secondary-darker\"\n\t\t| \"secondary-lighter\"\n\t\t| \"secondary-lightest\"\n\t\t| \"tertiary\"\n\t\t| \"tertiary-lighter\"\n\t\t| \"tertiary-lightest\"\n\t\t| \"info-lighter\"\n\t\t| \"gray\"\n\t\t| \"gray-darker\"\n\t\t| \"gray-lighter\"\n\t\t| \"gray-lightest\"\n\t\t| \"info\"\n\t\t| \"info-lighter\"\n\t\t| \"blend\"\n\t\t| \"success\"\n\t\t| \"success-lighter\"\n        | \"error\"\n        | \"error-lighter\"\n\t\t| \"transparent\";\n}\n\nexport interface BaseElementProps extends DefaultProps, HTMLAttributes<HTMLElement> {\n\tchildren?: React.ReactNode;\n}\n\nexport const BaseElement = React.forwardRef(\n\t(\n\t\t{\n\t\t\tpadding,\n\t\t\tpaddingTop,\n\t\t\tpaddingBottom,\n\t\t\tpaddingLeft,\n\t\t\tpaddingRight,\n\t\t\tmargin,\n\t\t\tmarginTop,\n\t\t\tmarginBottom,\n\t\t\tmarginLeft,\n\t\t\tmarginRight,\n\t\t\tsize,\n\t\t\theight,\n\t\t\twidth,\n\t\t\tbackground,\n\t\t\tclassName,\n\t\t\tchildren,\n\t\t\t...props\n\t\t}: BaseElementProps,\n\t\tref: React.Ref<HTMLDivElement>\n\t) => {\n\t\tconst cssClasses = clsx([\n\t\t\tclassName,\n\t\t\tsize && getSize(size),\n\t\t\tmargin && getMargin(margin),\n\t\t\tmarginTop && `margin-top-${marginTop}`,\n\t\t\tmarginBottom && `margin-bottom-${marginBottom}`,\n\t\t\tmarginLeft && `margin-left-${marginLeft}`,\n\t\t\tmarginRight && `margin-right-${marginRight}`,\n\t\t\tbackground && `background-${background}`,\n\t\t\tpadding && getPadding(padding),\n\t\t\tpaddingTop && `padding-top-${paddingTop}`,\n\t\t\tpaddingBottom && `padding-bottom-${paddingBottom}`,\n\t\t\tpaddingLeft && `padding-left-${paddingLeft}`,\n\t\t\tpaddingRight && `padding-right-${paddingRight}`,\n\t\t\theight && `height-${height}`,\n\t\t\twidth && `width-${width}`,\n\t\t]);\n\n\t\treturn (\n\t\t\t<div ref={ref} {...props} className={cssClasses} style={props.style}>\n\t\t\t\t{children}\n\t\t\t</div>\n\t\t);\n\t}\n);\nBaseElement.displayName = \"BaseElement\";\n\nfunction getSize(size?: Array<string> | string) {\n\tif (Array.isArray(size)) {\n\t\treturn size.map((s) => `size-${s}`).join(\" \");\n\t}\n\treturn `size-${size}`;\n}\n\nexport function getPadding(padding: Array<string> | string) {\n\tif (Array.isArray(padding)) {\n\t\tswitch (padding.length) {\n\t\t\tdefault:\n\t\t\tcase 1:\n\t\t\t\treturn `padding-${padding}`;\n\t\t\tcase 2:\n\t\t\t\treturn `padding-vertical-${padding[0]} padding-horizontal-${padding[1]}`;\n\t\t\tcase 3:\n\t\t\t\treturn `padding-top-${padding[0]} padding-horizontal-${padding[1]}\n                padding-bottom-${padding[2]}`;\n\t\t\tcase 4:\n\t\t\t\treturn `padding-top-${padding[0]} padding-right-${padding[1]}\n                padding-bottom-${padding[2]} padding-left-${padding[3]}`;\n\t\t}\n\t}\n\n\treturn `padding-${padding}`;\n}\n\nexport function getMargin(margin: Array<string> | string) {\n\tif (Array.isArray(margin)) {\n\t\tswitch (margin.length) {\n\t\t\tdefault:\n\t\t\tcase 1:\n\t\t\t\treturn `margin-${margin}`;\n\t\t\tcase 2:\n\t\t\t\treturn `margin-vertical-${margin[0]} margin-horizontal-${margin[1]}`;\n\t\t\tcase 3:\n\t\t\t\treturn `margin-top-${margin[0]} margin-horizontal-${margin[1]}\n                                margin-bottom-${margin[2]}`;\n\t\t\tcase 4:\n\t\t\t\treturn `margin-top-${margin[0]} margin-right-${margin[1]}\n                                margin-bottom-${margin[2]} margin-left-${margin[3]}`;\n\t\t}\n\t}\n\n\treturn `margin-${margin}`;\n}\n","// extracted by mini-css-extract-plugin\nexport default {\"block\":\"block--Box-module--RVtyR\",\"inline\":\"inline--Box-module--vnCUR\",\"horizontal\":\"horizontal--Box-module--k6unr\",\"horizontal-reverse\":\"horizontal-reverse--Box-module--S3XqX\",\"left\":\"left--Box-module--Vu_pE\",\"center\":\"center--Box-module--KdFt0\",\"right\":\"right--Box-module--HR3kC\",\"top\":\"top--Box-module--nDleq\",\"middle\":\"middle--Box-module--M3c3W\",\"bottom\":\"bottom--Box-module--V_qzA\",\"around\":\"around--Box-module--_HrjS\",\"between\":\"between--Box-module--Z7ab8\",\"evenly\":\"evenly--Box-module--TSjl5\",\"vertical\":\"vertical--Box-module--LEvNT\",\"vertical-reverse\":\"vertical-reverse--Box-module--nWSt6\",\"wrap-wrap\":\"wrap-wrap--Box-module--WbzGs\",\"wrap-wrap-reverse\":\"wrap-wrap-reverse--Box-module--ILOkd\",\"wrap-no-wrap\":\"wrap-no-wrap--Box-module--YIyrN\",\"size-full\":\"size-full--Box-module--aLvxc\",\"size-full-width\":\"size-full-width--Box-module--uXMpq\",\"size-full-height\":\"size-full-height--Box-module--QgP_t\",\"size-half-width\":\"size-half-width--Box-module--uZ8Xr\",\"size-half-height\":\"size-half-height--Box-module--gwieV\",\"size-minimal\":\"size-minimal--Box-module--w6UmZ\",\"size-minimal-width\":\"size-minimal-width--Box-module--Uscv3\",\"size-minimal-height\":\"size-minimal-height--Box-module--SIWkV\",\"position-left\":\"position-left--Box-module--O6qlC\",\"position-center\":\"position-center--Box-module--ioS6_\",\"position-right\":\"position-right--Box-module--eU5c2\",\"background-primary\":\"background-primary--Box-module--ximJw\",\"background-secondary\":\"background-secondary--Box-module--a21Hx\",\"background-tertiary\":\"background-tertiary--Box-module--nzeyz\",\"background-gray\":\"background-gray--Box-module--rFgdM\",\"background-gray-light\":\"background-gray-light--Box-module--uGo8u\",\"show-pointer-cursor\":\"show-pointer-cursor--Box-module--hLDpS\"};","import clsx from \"clsx\";\nimport React from \"react\";\nimport { BaseElement, BaseElementProps, baseSizeList } from \"./BaseElement\";\nimport styles from \"./Box.module.scss\";\n\ntype alignments = \"left\" | \"center\" | \"right\" | \"top\" | \"middle\" | \"bottom\" | \"around\" | \"between\" | \"evenly\";\n\nexport interface BoxProps extends BaseElementProps {\n\torientation?: \"horizontal\" | \"vertical\" | \"horizontal-reverse\" | \"vertical-reverse\";\n\talign?: Array<alignments> | alignments;\n\tgap?: baseSizeList;\n\twrap?: \"wrap\" | \"wrap-reverse\" | \"no-wrap\";\n\tposition?: \"left\" | \"center\" | \"right\";\n\tinline?: boolean;\n\tclassName?: string;\n\tchildren?: React.ReactNode;\n}\n\nexport const Box = ({ orientation, align, gap, wrap, position, inline = false, className, ...props }: BoxProps) => {\n\tconst cssClasses = clsx([\n\t\tstyles.block,\n\t\torientation && styles[`${orientation}`],\n\t\tgetAlign(align, orientation),\n\t\tgap && `gap-${gap}`,\n\t\twrap && styles[`wrap-${wrap}`],\n\t\tposition && styles[`position-${position}`],\n\t\tinline && styles.inline,\n\t\tprops.onClick && styles[\"show-pointer-cursor\"],\n\t\tclassName,\n\t]);\n\n\treturn (\n\t\t<BaseElement {...props} className={cssClasses}>\n\t\t\t{props.children}\n\t\t</BaseElement>\n\t);\n};\n\nfunction getAlign(align: Array<string> | string, orientation?: string) {\n\tif (!orientation) {\n\t\treturn \"\";\n\t}\n\tif (Array.isArray(align)) {\n\t\treturn align.map((al) => styles[al]).join(\" \");\n\t}\n\n\treturn styles[align];\n}\n","import { OrganisationsOrganisationExperienceLevelChoices } from \"@base/core/graphql\";\nimport Cookies from \"js-cookie\";\nimport { create } from \"zustand\";\nimport { createJSONStorage, persist } from \"zustand/middleware\";\n\nconst cookieStorage = {\n\tgetItem: (name: string) => Cookies.get(name) ?? null,\n\tsetItem: (name: string, value: string) => Cookies.set(name, value, { expires: 7 }),\n\tremoveItem: (name: string) => Cookies.remove(name),\n};\n\nexport interface OrganisationData {\n\tid: string;\n\tname: string;\n\tcountry: string;\n\tcurrency: string;\n\tcapabilities: Record<string, boolean>;\n\tpartner: { id: string; name: string; logo: string } | null;\n\tuserRoles: string[];\n\tisValid: boolean;\n\ttype: string;\n\tcompanyType: string;\n\tcreatorRole?: string;\n\texperienceLevel?: OrganisationsOrganisationExperienceLevelChoices;\n\tcreated?: string;\n}\n\ninterface OrgStore {\n\tselectedOrgId: string;\n\torganisationData: OrganisationData | null;\n\tloading: boolean;\n\tshowChecklist: boolean;\n\thideAuthorizedSharesPrompt: boolean;\n\torgResetting: boolean;\n\tinitialize: (orgData: OrganisationData) => void;\n\tresetOrganisation: (orgId?: string, redirectPath?: string) => void;\n\tsetShowChecklist: (show: boolean) => void;\n\tsetHideAuthorizedSharesPrompt: (hide: boolean) => void;\n\tcanEditShareRegistry: boolean;\n\tcanAdminShareRegistry: boolean;\n\tisLLC: boolean;\n}\n\nconst REDIRECT_KEY = \"org-bad-redirects\";\nconst REDIRECT_LIMIT = 3;\n\nconst safeCount = (): number => {\n\tconst raw = localStorage.getItem(REDIRECT_KEY);\n\tconst parsed = parseInt(raw || \"0\", 10);\n\treturn Number.isNaN(parsed) ? 0 : parsed;\n};\n\nconst badOrgDetection = (orgId: string) => {\n\tif (orgId === \"00000000-0000-0000-0000-00000000000\") {\n\t\tconsole.error(\"Invalid organisation ID detected.\");\n\t\tCookies.remove(\"org-store\", { path: \"/\" });\n\n\t\t// Increment counter safely\n\t\tconst count = safeCount() + 1;\n\t\ttry {\n\t\t\tlocalStorage.setItem(REDIRECT_KEY, String(count));\n\t\t} catch {\n\t\t\t// If localStorage is full or inaccessible, fallback to in-memory redirect\n\t\t\tconsole.warn(\"Could not write redirect counter to localStorage.\");\n\t\t}\n\n\t\tif (count >= REDIRECT_LIMIT) {\n\t\t\talert(\n\t\t\t\t\"We detected repeated redirects while loading your organisation. \" +\n\t\t\t\t\t\"We'll log you out to reset your session. If this keeps happening, please contact support.\"\n\t\t\t);\n\t\t\tlocalStorage.removeItem(REDIRECT_KEY);\n\t\t\twindow.location.replace(\"/resetsession\");\n\t\t} else {\n\t\t\twindow.location.replace(\"/\");\n\t\t}\n\t\treturn true;\n\t}\n\n\t// Success: clear counter\n\tlocalStorage.removeItem(REDIRECT_KEY);\n\treturn false;\n};\n\nexport const useOrgStore = create<OrgStore>()(\n\tpersist(\n\t\t(set, get) => ({\n\t\t\tselectedOrgId: \"\",\n\t\t\torgResetting: false,\n\n\t\t\torganisationData: null,\n\t\t\tloading: false,\n\t\t\terror: null,\n\n\t\t\tshowChecklist: true,\n\t\t\thideAuthorizedSharesPrompt: false,\n\t\t\tcanAdminShareRegistry: false,\n\t\t\tcanEditShareRegistry: false,\n\t\t\tisLLC: false,\n\n\t\t\tresetOrganisation: (id, redirectPath = \"/\") => {\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tset({ organisationData: null, loading: false, selectedOrgId: id || \"\", orgResetting: true });\n\t\t\t\t\twindow.location.replace(redirectPath);\n\t\t\t\t}, 0);\n\t\t\t},\n\n\t\t\tsetShowChecklist: (show) => set({ showChecklist: show }),\n\t\t\tsetHideAuthorizedSharesPrompt: (hide) => set({ hideAuthorizedSharesPrompt: hide }),\n\t\t\tinitialize: (orgData) => {\n\t\t\t\tconst orgResetting = get().orgResetting;\n\t\t\t\tif (badOrgDetection(orgData.id)) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tconst hasUserCompanyRoles = (roles) => {\n\t\t\t\t\tconst desiredRoles = Array.isArray(roles) ? roles : [roles];\n\t\t\t\t\tif (!orgData.userRoles) return false;\n\t\t\t\t\treturn desiredRoles.some((role) => orgData.userRoles.includes(role));\n\t\t\t\t};\n\n\t\t\t\tset({\n\t\t\t\t\tselectedOrgId: orgData.id,\n\t\t\t\t\torganisationData: orgData,\n\t\t\t\t\tloading: false,\n\t\t\t\t\torgResetting: false,\n\t\t\t\t\tcanAdminShareRegistry: hasUserCompanyRoles([\"ADVISOR\", \"ADMIN\", \"SUPPORT\"]),\n\t\t\t\t\tcanEditShareRegistry: hasUserCompanyRoles([\"ADVISOR\", \"EDIT\", \"ADMIN\", \"SUPPORT\"]),\n\t\t\t\t\tisLLC: orgData.type === \"LLC\",\n\t\t\t\t});\n\n\t\t\t\tif (orgResetting) {\n\t\t\t\t\tconsole.debug(\"Organisation reset detected, reloading organisation data.\");\n\t\t\t\t}\n\t\t\t},\n\t\t}),\n\t\t{\n\t\t\tname: \"org-store\",\n\t\t\tstorage: createJSONStorage(() => cookieStorage),\n\t\t\tpartialize: (state) => {\n\t\t\t\tif (badOrgDetection(state?.selectedOrgId)) {\n\t\t\t\t\treturn undefined;\n\t\t\t\t}\n\t\t\t\treturn {\n\t\t\t\t\tselectedOrgId: state.selectedOrgId,\n\t\t\t\t\tshowChecklist: state.showChecklist,\n\t\t\t\t\thideAuthorizedSharesPrompt: state.hideAuthorizedSharesPrompt,\n\t\t\t\t};\n\t\t\t},\n\t\t}\n\t)\n);\n","// extracted by mini-css-extract-plugin\nexport default {\"common\":\"common--Button-module--MSHn4\",\"primary\":\"primary--Button-module--nVoOg\",\"secondary\":\"secondary--Button-module--Zm1sZ\",\"tertiary\":\"tertiary--Button-module--J5BE4\",\"outlined\":\"outlined--Button-module--a4Yx4\",\"link\":\"link--Button-module--oxeGW\",\"error\":\"error--Button-module--IdQfW\",\"admin\":\"admin--Button-module--dG9zG\",\"tiny\":\"tiny--Button-module--m3G3p\",\"iconOnly\":\"iconOnly--Button-module--S09kM\",\"small\":\"small--Button-module--pnj_t\",\"regular\":\"regular--Button-module--Z4WmX\",\"big\":\"big--Button-module--gWPzL\",\"loading\":\"loading--Button-module--_O1iD\",\"iconLeft\":\"iconLeft--Button-module--iWqsA\",\"iconRight\":\"iconRight--Button-module--XGGzo\",\"loader\":\"loader--Button-module--jiYfZ\",\"loaderIcon\":\"loaderIcon--Button-module--LiM6a\",\"loaderSmall\":\"loaderSmall--Button-module--z0bJy\",\"loaderRegular\":\"loaderRegular--Button-module--RZfFF\",\"loaderBig\":\"loaderBig--Button-module--kmXxm\",\"loaderAnimation\":\"loaderAnimation--Button-module--cCZg5\"};","import { baseSizeList, DefaultProps, getMargin } from \"@base/components/common/primitives/BaseElement\";\nimport { Icon, rotation } from \"@base/components/common/primitives/Icon\";\nimport clsx from \"clsx\";\nimport React from \"react\";\nimport styles from \"./Button.module.scss\";\n\nexport type ButtonVariants = \"primary\" | \"secondary\" | \"tertiary\" | \"outlined\" | \"link\" | \"error\" | \"admin\";\n\nexport interface ButtonProps\n\textends Omit<DefaultProps, \"size\" | \"background\">,\n\t\tReact.ButtonHTMLAttributes<HTMLButtonElement> {\n\tvariant?: ButtonVariants;\n\tloading?: boolean;\n\tsize?: \"tiny\" | \"small\" | \"regular\" | \"big\";\n\ticon?: string;\n\ticonPlacement?: \"left\" | \"right\";\n\ticonRotate?: rotation;\n\ticonSize?: baseSizeList;\n\tdataTest?: string;\n}\n\nconst loaderSizes = {\n\tsmall: styles.loaderSmall,\n\tregular: styles.loaderRegular,\n\tbig: styles.loaderBig,\n};\n\nconst Loader = ({ size }: { size: ButtonProps[\"size\"] }) => {\n\treturn (\n\t\t<div className={clsx(styles.loader, loaderSizes[size])}>\n\t\t\t{new Array(12).fill(null).map((_, index) => (\n\t\t\t\t<div key={index} className={styles.loaderIcon} />\n\t\t\t))}\n\t\t</div>\n\t);\n};\n\nconst buttonVariants = {\n\tprimary: styles.primary,\n\tsecondary: styles.secondary,\n\ttertiary: styles.tertiary,\n\toutlined: styles.outlined,\n\tlink: styles.link,\n\terror: styles.error,\n\tadmin: styles.admin,\n};\n\nconst buttonSizes = {\n\ttiny: styles.tiny,\n\tsmall: styles.small,\n\tregular: styles.regular,\n\tbig: styles.big,\n};\n\nconst iconSizes = {\n\tsmall: \"4x\",\n\tregular: \"5x\",\n\tbig: \"6x\",\n};\n\nconst iconPosition = {\n\tleft: styles.iconLeft,\n\tright: styles.iconRight,\n};\n\nexport const Button = ({\n\tchildren,\n\tsize = \"regular\",\n\tvariant = \"primary\",\n\tloading = false,\n\tclassName,\n\ticon,\n\ticonPlacement = \"left\",\n\ticonRotate = \"top\",\n\ticonSize,\n\tmargin,\n\tmarginTop,\n\tmarginBottom,\n\tmarginLeft,\n\tmarginRight,\n\twidth,\n\tdataTest,\n\tdisabled,\n\t...props\n}: ButtonProps) => {\n\tconst cssClasses = clsx([\n\t\tmargin && getMargin(margin),\n\t\tmarginTop && `margin-top-${marginTop}`,\n\t\tmarginBottom && `margin-bottom-${marginBottom}`,\n\t\tmarginLeft && `margin-left-${marginLeft}`,\n\t\tmarginRight && `margin-right-${marginRight}`,\n\t\tloading && styles.loading,\n\t\tstyles.common,\n\t\tbuttonVariants[variant],\n\t\tbuttonSizes[size],\n\t\t(icon || loading) && !children && styles.iconOnly,\n\t\ticonPosition[iconPlacement],\n\t\twidth && `width-${width}`,\n\t\tclassName,\n\t]);\n\n\treturn (\n\t\t<button data-test={dataTest} className={cssClasses} disabled={loading || disabled} type=\"button\" {...props}>\n\t\t\t{loading && <Loader size={size} />}\n\t\t\t{!loading && icon && (\n\t\t\t\t<Icon source={icon} rotate={iconRotate} size={iconSize ?? (iconSizes[size] as Partial<baseSizeList>)} />\n\t\t\t)}\n\t\t\t{children}\n\t\t</button>\n\t);\n};\n","// extracted by mini-css-extract-plugin\nexport default {\"line\":\"line--Line-module--el7MN\",\"orientation-horizontal\":\"orientation-horizontal--Line-module--uq2sp\",\"orientation-vertical\":\"orientation-vertical--Line-module--BIGp1\",\"background-primary\":\"background-primary--Line-module--Rc9TQ\",\"background-secondary\":\"background-secondary--Line-module--vlt_M\",\"background-tertiary\":\"background-tertiary--Line-module--UDW4H\",\"background-gray\":\"background-gray--Line-module--nPRZz\",\"background-gray-light\":\"background-gray-light--Line-module--ClCm9\"};","import clsx from \"clsx\";\nimport React from \"react\";\nimport { BaseElement, BaseElementProps } from \"./BaseElement\";\nimport styles from \"./Line.module.scss\";\n\nexport interface LineProps extends BaseElementProps {\n\tclassName?: string;\n\torientation?: \"horizontal\" | \"vertical\";\n}\n\nexport const Line = ({ orientation, className, ...props }: LineProps) => {\n\tconst classList = clsx([styles.line, orientation && styles[`${orientation}`], className]);\n\n\treturn <BaseElement {...props} className={classList}></BaseElement>;\n};\n","// extracted by mini-css-extract-plugin\nexport default {\"shape\":\"shape--Shape-module--X25L8\",\"height--100x\":\"height--100x--Shape-module--mCcYB\",\"height--99x\":\"height--99x--Shape-module--eDouo\",\"height--98x\":\"height--98x--Shape-module--y5QWW\",\"height--97x\":\"height--97x--Shape-module--Mx2cX\",\"height--96x\":\"height--96x--Shape-module--zZd8R\",\"height--95x\":\"height--95x--Shape-module--qokLE\",\"height--94x\":\"height--94x--Shape-module--lcqr5\",\"height--93x\":\"height--93x--Shape-module--LFFzl\",\"height--92x\":\"height--92x--Shape-module--jkm0y\",\"height--91x\":\"height--91x--Shape-module--qtKG_\",\"height--90x\":\"height--90x--Shape-module--sIgkq\",\"height--89x\":\"height--89x--Shape-module--wxAGp\",\"height--88x\":\"height--88x--Shape-module--U_qSx\",\"height--87x\":\"height--87x--Shape-module--FQSLH\",\"height--86x\":\"height--86x--Shape-module--VnHBI\",\"height--85x\":\"height--85x--Shape-module--B1EMt\",\"height--84x\":\"height--84x--Shape-module--YvHmb\",\"height--83x\":\"height--83x--Shape-module--G8zBe\",\"height--82x\":\"height--82x--Shape-module--lsrpA\",\"height--81x\":\"height--81x--Shape-module--vwR8D\",\"height--80x\":\"height--80x--Shape-module--DQLss\",\"height--79x\":\"height--79x--Shape-module--EVvHd\",\"height--78x\":\"height--78x--Shape-module--d_fZw\",\"height--77x\":\"height--77x--Shape-module--U_U04\",\"height--76x\":\"height--76x--Shape-module--HG20z\",\"height--75x\":\"height--75x--Shape-module--hMRHC\",\"height--74x\":\"height--74x--Shape-module--TC9iZ\",\"height--73x\":\"height--73x--Shape-module--Dw8RU\",\"height--72x\":\"height--72x--Shape-module--EvDR1\",\"height--71x\":\"height--71x--Shape-module--RsFkv\",\"height--70x\":\"height--70x--Shape-module--XGt8f\",\"height--69x\":\"height--69x--Shape-module--OMmy8\",\"height--68x\":\"height--68x--Shape-module--lqHYz\",\"height--67x\":\"height--67x--Shape-module--zr7Lh\",\"height--66x\":\"height--66x--Shape-module--X2Y7V\",\"height--65x\":\"height--65x--Shape-module--kyCrm\",\"height--64x\":\"height--64x--Shape-module--cNa49\",\"height--63x\":\"height--63x--Shape-module--RxmFB\",\"height--62x\":\"height--62x--Shape-module--Py46K\",\"height--61x\":\"height--61x--Shape-module--HZoJ7\",\"height--60x\":\"height--60x--Shape-module--U9ulZ\",\"height--59x\":\"height--59x--Shape-module--zDGYC\",\"height--58x\":\"height--58x--Shape-module--LOtB8\",\"height--57x\":\"height--57x--Shape-module--f9gsb\",\"height--56x\":\"height--56x--Shape-module--ffn3D\",\"height--55x\":\"height--55x--Shape-module--YBXN_\",\"height--54x\":\"height--54x--Shape-module--e7pKy\",\"height--53x\":\"height--53x--Shape-module--YGTQ1\",\"height--52x\":\"height--52x--Shape-module--AG2HN\",\"height--51x\":\"height--51x--Shape-module--h8JLg\",\"height--50x\":\"height--50x--Shape-module--UyvLU\",\"height--49x\":\"height--49x--Shape-module--NUbim\",\"height--48x\":\"height--48x--Shape-module--uYRP_\",\"height--47x\":\"height--47x--Shape-module--WNtGk\",\"height--46x\":\"height--46x--Shape-module--EPmVo\",\"height--45x\":\"height--45x--Shape-module--BALPz\",\"height--44x\":\"height--44x--Shape-module--z4IK6\",\"height--43x\":\"height--43x--Shape-module--P1I4D\",\"height--42x\":\"height--42x--Shape-module--zbASK\",\"height--41x\":\"height--41x--Shape-module--Yzaqe\",\"height--40x\":\"height--40x--Shape-module--LGYcs\",\"height--39x\":\"height--39x--Shape-module--KDRvY\",\"height--38x\":\"height--38x--Shape-module--xQpci\",\"height--37x\":\"height--37x--Shape-module--H8qNz\",\"height--36x\":\"height--36x--Shape-module--AF7it\",\"height--35x\":\"height--35x--Shape-module--x7995\",\"height--34x\":\"height--34x--Shape-module--NnCE2\",\"height--33x\":\"height--33x--Shape-module--K2gGq\",\"height--32x\":\"height--32x--Shape-module--LOu8l\",\"height--31x\":\"height--31x--Shape-module--SLLrq\",\"height--30x\":\"height--30x--Shape-module--Zi36T\",\"height--29x\":\"height--29x--Shape-module--BJmRn\",\"height--28x\":\"height--28x--Shape-module--C5Dcd\",\"height--27x\":\"height--27x--Shape-module--OO5HC\",\"height--26x\":\"height--26x--Shape-module--wGeC2\",\"height--25x\":\"height--25x--Shape-module--dQ1Ly\",\"height--24x\":\"height--24x--Shape-module--SIagc\",\"height--23x\":\"height--23x--Shape-module--SBrah\",\"height--22x\":\"height--22x--Shape-module--Dva1J\",\"height--21x\":\"height--21x--Shape-module--qhxk6\",\"height--20x\":\"height--20x--Shape-module--L66lA\",\"height--19x\":\"height--19x--Shape-module--Vepwv\",\"height--18x\":\"height--18x--Shape-module--zLaEH\",\"height--17x\":\"height--17x--Shape-module--dB94v\",\"height--16x\":\"height--16x--Shape-module--aP8fB\",\"height--15x\":\"height--15x--Shape-module--HFy8s\",\"height--14x\":\"height--14x--Shape-module--Bq76s\",\"height--13x\":\"height--13x--Shape-module--tK2qK\",\"height--12x\":\"height--12x--Shape-module--AeKt2\",\"height--11x\":\"height--11x--Shape-module--z9z6u\",\"height--10x\":\"height--10x--Shape-module--v7SzO\",\"height--9x\":\"height--9x--Shape-module--ONJs6\",\"height--8x\":\"height--8x--Shape-module--o6yhi\",\"height--7x\":\"height--7x--Shape-module--v6jyN\",\"height--6x\":\"height--6x--Shape-module--Cez90\",\"height--5x\":\"height--5x--Shape-module--z8Ueu\",\"height--4x\":\"height--4x--Shape-module--ako8p\",\"height--3x\":\"height--3x--Shape-module--Tgs8H\",\"height--2x\":\"height--2x--Shape-module--m1hQY\",\"height--1x\":\"height--1x--Shape-module--N8Utd\",\"height--05x\":\"height--05x--Shape-module--rKEFk\",\"height--025x\":\"height--025x--Shape-module--DxEQN\",\"height-0x\":\"height-0x--Shape-module--oJGz1\",\"height-0\":\"height-0--Shape-module--ZPtAz\",\"height-025x\":\"height-025x--Shape-module--kTxtY\",\"height-05x\":\"height-05x--Shape-module--sm4sD\",\"height-1x\":\"height-1x--Shape-module--Axzpx\",\"height-2x\":\"height-2x--Shape-module--LHuN9\",\"height-3x\":\"height-3x--Shape-module--Y9j4s\",\"height-4x\":\"height-4x--Shape-module--WmDW_\",\"height-5x\":\"height-5x--Shape-module--cSBiM\",\"height-6x\":\"height-6x--Shape-module--QLb6k\",\"height-7x\":\"height-7x--Shape-module--GVBty\",\"height-8x\":\"height-8x--Shape-module--LgO1S\",\"height-9x\":\"height-9x--Shape-module--ugp4c\",\"height-10x\":\"height-10x--Shape-module--ZswKS\",\"height-11x\":\"height-11x--Shape-module--GCEe0\",\"height-12x\":\"height-12x--Shape-module--TZkKY\",\"height-13x\":\"height-13x--Shape-module--JVyb0\",\"height-14x\":\"height-14x--Shape-module--Hpjq8\",\"height-15x\":\"height-15x--Shape-module--sa08r\",\"height-16x\":\"height-16x--Shape-module--yJymQ\",\"height-17x\":\"height-17x--Shape-module--NOy_h\",\"height-18x\":\"height-18x--Shape-module--xq92B\",\"height-19x\":\"height-19x--Shape-module--gB37E\",\"height-20x\":\"height-20x--Shape-module--IGquF\",\"height-21x\":\"height-21x--Shape-module--pZxqA\",\"height-22x\":\"height-22x--Shape-module--miE8h\",\"height-23x\":\"height-23x--Shape-module--lP1Jy\",\"height-24x\":\"height-24x--Shape-module--FV16D\",\"height-25x\":\"height-25x--Shape-module--bRY66\",\"height-26x\":\"height-26x--Shape-module--YkWSA\",\"height-27x\":\"height-27x--Shape-module--dbk5D\",\"height-28x\":\"height-28x--Shape-module--kBlcf\",\"height-29x\":\"height-29x--Shape-module--gH_F8\",\"height-30x\":\"height-30x--Shape-module--_DVEZ\",\"height-31x\":\"height-31x--Shape-module--cOe0g\",\"height-32x\":\"height-32x--Shape-module--SkPaH\",\"height-33x\":\"height-33x--Shape-module--bRL54\",\"height-34x\":\"height-34x--Shape-module--sAFnK\",\"height-35x\":\"height-35x--Shape-module--PlQcc\",\"height-36x\":\"height-36x--Shape-module--BW3fN\",\"height-37x\":\"height-37x--Shape-module--arbh7\",\"height-38x\":\"height-38x--Shape-module--ykQRt\",\"height-39x\":\"height-39x--Shape-module--fKT21\",\"height-40x\":\"height-40x--Shape-module--ipCso\",\"height-41x\":\"height-41x--Shape-module--QCsda\",\"height-42x\":\"height-42x--Shape-module--TX1b7\",\"height-43x\":\"height-43x--Shape-module--IaJj5\",\"height-44x\":\"height-44x--Shape-module--PSpco\",\"height-45x\":\"height-45x--Shape-module--ITqCv\",\"height-46x\":\"height-46x--Shape-module--D5tuX\",\"height-47x\":\"height-47x--Shape-module--mCwdF\",\"height-48x\":\"height-48x--Shape-module--ox3eG\",\"height-49x\":\"height-49x--Shape-module--mvcgI\",\"height-50x\":\"height-50x--Shape-module--IU02y\",\"height-51x\":\"height-51x--Shape-module--FB1S5\",\"height-52x\":\"height-52x--Shape-module--l5B_E\",\"height-53x\":\"height-53x--Shape-module--J5UYN\",\"height-54x\":\"height-54x--Shape-module--ZYi5i\",\"height-55x\":\"height-55x--Shape-module--Itq6V\",\"height-56x\":\"height-56x--Shape-module--Lz8IS\",\"height-57x\":\"height-57x--Shape-module--fJu4S\",\"height-58x\":\"height-58x--Shape-module--PIB1a\",\"height-59x\":\"height-59x--Shape-module--WOzDZ\",\"height-60x\":\"height-60x--Shape-module--GHYPM\",\"height-61x\":\"height-61x--Shape-module--N9CuG\",\"height-62x\":\"height-62x--Shape-module--LBdYF\",\"height-63x\":\"height-63x--Shape-module--W0e6K\",\"height-64x\":\"height-64x--Shape-module--cjAxZ\",\"height-65x\":\"height-65x--Shape-module--mcqYZ\",\"height-66x\":\"height-66x--Shape-module--H96Py\",\"height-67x\":\"height-67x--Shape-module--p7jGo\",\"height-68x\":\"height-68x--Shape-module--p09lH\",\"height-69x\":\"height-69x--Shape-module--hl54S\",\"height-70x\":\"height-70x--Shape-module--lCw1H\",\"height-71x\":\"height-71x--Shape-module--arZpY\",\"height-72x\":\"height-72x--Shape-module--ph7S9\",\"height-73x\":\"height-73x--Shape-module--maWfo\",\"height-74x\":\"height-74x--Shape-module--hH2Xv\",\"height-75x\":\"height-75x--Shape-module--esfPY\",\"height-76x\":\"height-76x--Shape-module--hK1LW\",\"height-77x\":\"height-77x--Shape-module--s9Ioo\",\"height-78x\":\"height-78x--Shape-module--zvMhW\",\"height-79x\":\"height-79x--Shape-module--IzF4G\",\"height-80x\":\"height-80x--Shape-module--HbQk1\",\"height-81x\":\"height-81x--Shape-module--fSLhV\",\"height-82x\":\"height-82x--Shape-module--pWaz8\",\"height-83x\":\"height-83x--Shape-module--ifHlo\",\"height-84x\":\"height-84x--Shape-module--gtiQK\",\"height-85x\":\"height-85x--Shape-module--pvzuO\",\"height-86x\":\"height-86x--Shape-module--hUU8e\",\"height-87x\":\"height-87x--Shape-module--TmCzN\",\"height-88x\":\"height-88x--Shape-module--fcqBd\",\"height-89x\":\"height-89x--Shape-module--BTVSq\",\"height-90x\":\"height-90x--Shape-module--G6Wi8\",\"height-91x\":\"height-91x--Shape-module--ojK8T\",\"height-92x\":\"height-92x--Shape-module--U08wD\",\"height-93x\":\"height-93x--Shape-module--pnaSs\",\"height-94x\":\"height-94x--Shape-module--W4I9d\",\"height-95x\":\"height-95x--Shape-module--wgxNd\",\"height-96x\":\"height-96x--Shape-module--wl8Os\",\"height-97x\":\"height-97x--Shape-module--B0z1d\",\"height-98x\":\"height-98x--Shape-module--T7pUq\",\"height-99x\":\"height-99x--Shape-module--VNETy\",\"height-100x\":\"height-100x--Shape-module--BEBqL\",\"height-auto\":\"height-auto--Shape-module--Ts7HM\",\"height-half\":\"height-half--Shape-module--Qwpd_\",\"height-full\":\"height-full--Shape-module--KD1YO\",\"height-fit-content\":\"height-fit-content--Shape-module--aVGdv\",\"height-max-content\":\"height-max-content--Shape-module--uNLMV\",\"size--100x\":\"size--100x--Shape-module--fu8JK\",\"size--99x\":\"size--99x--Shape-module--GkKgu\",\"size--98x\":\"size--98x--Shape-module--zsNna\",\"size--97x\":\"size--97x--Shape-module--ob6OC\",\"size--96x\":\"size--96x--Shape-module--KAnZM\",\"size--95x\":\"size--95x--Shape-module--TZ9LC\",\"size--94x\":\"size--94x--Shape-module--VLwyd\",\"size--93x\":\"size--93x--Shape-module--cG9qi\",\"size--92x\":\"size--92x--Shape-module--yliDl\",\"size--91x\":\"size--91x--Shape-module--xWlSo\",\"size--90x\":\"size--90x--Shape-module--m2GYO\",\"size--89x\":\"size--89x--Shape-module--GgNp9\",\"size--88x\":\"size--88x--Shape-module--dQV8Y\",\"size--87x\":\"size--87x--Shape-module--sKtEy\",\"size--86x\":\"size--86x--Shape-module--BXXib\",\"size--85x\":\"size--85x--Shape-module--BlhYb\",\"size--84x\":\"size--84x--Shape-module--RL_LR\",\"size--83x\":\"size--83x--Shape-module--ZSzWM\",\"size--82x\":\"size--82x--Shape-module--GU6bK\",\"size--81x\":\"size--81x--Shape-module--tH77K\",\"size--80x\":\"size--80x--Shape-module--w5unF\",\"size--79x\":\"size--79x--Shape-module--_UiTN\",\"size--78x\":\"size--78x--Shape-module--W7g1v\",\"size--77x\":\"size--77x--Shape-module--LSL1e\",\"size--76x\":\"size--76x--Shape-module--QQJoL\",\"size--75x\":\"size--75x--Shape-module--RbnOU\",\"size--74x\":\"size--74x--Shape-module--NYMZ8\",\"size--73x\":\"size--73x--Shape-module--pHtkQ\",\"size--72x\":\"size--72x--Shape-module--vWrm8\",\"size--71x\":\"size--71x--Shape-module--zZvCW\",\"size--70x\":\"size--70x--Shape-module--gpQqO\",\"size--69x\":\"size--69x--Shape-module--TqL4N\",\"size--68x\":\"size--68x--Shape-module--wFc7D\",\"size--67x\":\"size--67x--Shape-module--R1eSo\",\"size--66x\":\"size--66x--Shape-module--BC9oW\",\"size--65x\":\"size--65x--Shape-module--wOTB9\",\"size--64x\":\"size--64x--Shape-module--HBmHY\",\"size--63x\":\"size--63x--Shape-module--k2VMB\",\"size--62x\":\"size--62x--Shape-module--WJdx_\",\"size--61x\":\"size--61x--Shape-module--xd3DX\",\"size--60x\":\"size--60x--Shape-module--PCOCn\",\"size--59x\":\"size--59x--Shape-module--pcreo\",\"size--58x\":\"size--58x--Shape-module--Uj8n1\",\"size--57x\":\"size--57x--Shape-module--FyGpM\",\"size--56x\":\"size--56x--Shape-module--WRE1t\",\"size--55x\":\"size--55x--Shape-module--aRsDu\",\"size--54x\":\"size--54x--Shape-module--F191_\",\"size--53x\":\"size--53x--Shape-module--rK_od\",\"size--52x\":\"size--52x--Shape-module--hP9Fd\",\"size--51x\":\"size--51x--Shape-module--hfc9S\",\"size--50x\":\"size--50x--Shape-module--fNz8s\",\"size--49x\":\"size--49x--Shape-module--Mubl7\",\"size--48x\":\"size--48x--Shape-module--srcoi\",\"size--47x\":\"size--47x--Shape-module--f1nO0\",\"size--46x\":\"size--46x--Shape-module--lyAmj\",\"size--45x\":\"size--45x--Shape-module--mjEWz\",\"size--44x\":\"size--44x--Shape-module--RssvP\",\"size--43x\":\"size--43x--Shape-module--UGXQD\",\"size--42x\":\"size--42x--Shape-module--lvT92\",\"size--41x\":\"size--41x--Shape-module--wsVsk\",\"size--40x\":\"size--40x--Shape-module--jt8eh\",\"size--39x\":\"size--39x--Shape-module--cRIlK\",\"size--38x\":\"size--38x--Shape-module--WZzlU\",\"size--37x\":\"size--37x--Shape-module--Q8B8u\",\"size--36x\":\"size--36x--Shape-module--y6u3M\",\"size--35x\":\"size--35x--Shape-module--bJnWv\",\"size--34x\":\"size--34x--Shape-module--La9Nd\",\"size--33x\":\"size--33x--Shape-module--KPkJj\",\"size--32x\":\"size--32x--Shape-module--QI0hd\",\"size--31x\":\"size--31x--Shape-module--ug7Es\",\"size--30x\":\"size--30x--Shape-module--av43C\",\"size--29x\":\"size--29x--Shape-module--s1P7S\",\"size--28x\":\"size--28x--Shape-module--FLVPj\",\"size--27x\":\"size--27x--Shape-module--h7wBH\",\"size--26x\":\"size--26x--Shape-module--quy_G\",\"size--25x\":\"size--25x--Shape-module--tXpep\",\"size--24x\":\"size--24x--Shape-module--OOsI_\",\"size--23x\":\"size--23x--Shape-module--Ay51M\",\"size--22x\":\"size--22x--Shape-module--are_O\",\"size--21x\":\"size--21x--Shape-module--qOSyF\",\"size--20x\":\"size--20x--Shape-module--ENzNZ\",\"size--19x\":\"size--19x--Shape-module--FDQqS\",\"size--18x\":\"size--18x--Shape-module--jXIk_\",\"size--17x\":\"size--17x--Shape-module--RIAcv\",\"size--16x\":\"size--16x--Shape-module--nNIr0\",\"size--15x\":\"size--15x--Shape-module--QY22r\",\"size--14x\":\"size--14x--Shape-module--txRJk\",\"size--13x\":\"size--13x--Shape-module--MhcEr\",\"size--12x\":\"size--12x--Shape-module--Y9kGS\",\"size--11x\":\"size--11x--Shape-module--Z0mEk\",\"size--10x\":\"size--10x--Shape-module--k4IgW\",\"size--9x\":\"size--9x--Shape-module--tfosH\",\"size--8x\":\"size--8x--Shape-module--NA_eE\",\"size--7x\":\"size--7x--Shape-module--B5yoZ\",\"size--6x\":\"size--6x--Shape-module--piOa_\",\"size--5x\":\"size--5x--Shape-module--riXVO\",\"size--4x\":\"size--4x--Shape-module--V_vgj\",\"size--3x\":\"size--3x--Shape-module--VZH9w\",\"size--2x\":\"size--2x--Shape-module--avL4X\",\"size--1x\":\"size--1x--Shape-module--eqlk_\",\"size--05x\":\"size--05x--Shape-module--tavhB\",\"size--025x\":\"size--025x--Shape-module--AQ_C_\",\"size-0x\":\"size-0x--Shape-module--q217B\",\"size-0\":\"size-0--Shape-module--gr_rj\",\"size-025x\":\"size-025x--Shape-module--fs_FR\",\"size-05x\":\"size-05x--Shape-module--Fn5C0\",\"size-1x\":\"size-1x--Shape-module--rq5P5\",\"size-2x\":\"size-2x--Shape-module--hoGAw\",\"size-3x\":\"size-3x--Shape-module--UgWdo\",\"size-4x\":\"size-4x--Shape-module--JNlpe\",\"size-5x\":\"size-5x--Shape-module--HxDqA\",\"size-6x\":\"size-6x--Shape-module--s1svV\",\"size-7x\":\"size-7x--Shape-module--_AezT\",\"size-8x\":\"size-8x--Shape-module--VFYRK\",\"size-9x\":\"size-9x--Shape-module--JXtcq\",\"size-10x\":\"size-10x--Shape-module--kGCiS\",\"size-11x\":\"size-11x--Shape-module--ibz4K\",\"size-12x\":\"size-12x--Shape-module--U8oAJ\",\"size-13x\":\"size-13x--Shape-module--RM5cv\",\"size-14x\":\"size-14x--Shape-module--hfnfp\",\"size-15x\":\"size-15x--Shape-module--UmBI4\",\"size-16x\":\"size-16x--Shape-module--YmPQT\",\"size-17x\":\"size-17x--Shape-module--seK0I\",\"size-18x\":\"size-18x--Shape-module--YgBgr\",\"size-19x\":\"size-19x--Shape-module--qb0tK\",\"size-20x\":\"size-20x--Shape-module--ilEA8\",\"size-21x\":\"size-21x--Shape-module--J36js\",\"size-22x\":\"size-22x--Shape-module--bDDCY\",\"size-23x\":\"size-23x--Shape-module--bN3N0\",\"size-24x\":\"size-24x--Shape-module--QjD6J\",\"size-25x\":\"size-25x--Shape-module--kRS1M\",\"size-26x\":\"size-26x--Shape-module--hHesc\",\"size-27x\":\"size-27x--Shape-module--_I6Gi\",\"size-28x\":\"size-28x--Shape-module--f_c09\",\"size-29x\":\"size-29x--Shape-module--BFuV2\",\"size-30x\":\"size-30x--Shape-module--UEU9V\",\"size-31x\":\"size-31x--Shape-module--TdQxg\",\"size-32x\":\"size-32x--Shape-module--7cLbk\",\"size-33x\":\"size-33x--Shape-module--bFhso\",\"size-34x\":\"size-34x--Shape-module--VNAgH\",\"size-35x\":\"size-35x--Shape-module--a9cTH\",\"size-36x\":\"size-36x--Shape-module--O8eaB\",\"size-37x\":\"size-37x--Shape-module--gNQyC\",\"size-38x\":\"size-38x--Shape-module--tdkpN\",\"size-39x\":\"size-39x--Shape-module--KEOsd\",\"size-40x\":\"size-40x--Shape-module--VgJjm\",\"size-41x\":\"size-41x--Shape-module--lAN8m\",\"size-42x\":\"size-42x--Shape-module--qmhfq\",\"size-43x\":\"size-43x--Shape-module--B3ZU8\",\"size-44x\":\"size-44x--Shape-module--CUPfu\",\"size-45x\":\"size-45x--Shape-module--IoVY3\",\"size-46x\":\"size-46x--Shape-module--qV2xK\",\"size-47x\":\"size-47x--Shape-module--0abUB\",\"size-48x\":\"size-48x--Shape-module--zhXb4\",\"size-49x\":\"size-49x--Shape-module--gtr41\",\"size-50x\":\"size-50x--Shape-module--z509o\",\"size-51x\":\"size-51x--Shape-module--e_uMg\",\"size-52x\":\"size-52x--Shape-module--tlhna\",\"size-53x\":\"size-53x--Shape-module--HBLAH\",\"size-54x\":\"size-54x--Shape-module--nd1uR\",\"size-55x\":\"size-55x--Shape-module--Dibd5\",\"size-56x\":\"size-56x--Shape-module--50zuS\",\"size-57x\":\"size-57x--Shape-module--cnAQj\",\"size-58x\":\"size-58x--Shape-module--zp3Jd\",\"size-59x\":\"size-59x--Shape-module--NJ6E7\",\"size-60x\":\"size-60x--Shape-module--FiCou\",\"size-61x\":\"size-61x--Shape-module--Z_sEb\",\"size-62x\":\"size-62x--Shape-module--mPZ2T\",\"size-63x\":\"size-63x--Shape-module--zErP1\",\"size-64x\":\"size-64x--Shape-module--lePl_\",\"size-65x\":\"size-65x--Shape-module--qPm7r\",\"size-66x\":\"size-66x--Shape-module--cuC_c\",\"size-67x\":\"size-67x--Shape-module--e5yQJ\",\"size-68x\":\"size-68x--Shape-module--_H0aR\",\"size-69x\":\"size-69x--Shape-module--einGj\",\"size-70x\":\"size-70x--Shape-module--OpHBP\",\"size-71x\":\"size-71x--Shape-module--WUs1J\",\"size-72x\":\"size-72x--Shape-module--EU96v\",\"size-73x\":\"size-73x--Shape-module--rKx9g\",\"size-74x\":\"size-74x--Shape-module--HzQOW\",\"size-75x\":\"size-75x--Shape-module--npbv5\",\"size-76x\":\"size-76x--Shape-module--vmk5u\",\"size-77x\":\"size-77x--Shape-module--A8ONS\",\"size-78x\":\"size-78x--Shape-module--QxLy7\",\"size-79x\":\"size-79x--Shape-module--NY0K9\",\"size-80x\":\"size-80x--Shape-module--zbl8d\",\"size-81x\":\"size-81x--Shape-module--wXNf0\",\"size-82x\":\"size-82x--Shape-module--LLdgD\",\"size-83x\":\"size-83x--Shape-module--u8SYM\",\"size-84x\":\"size-84x--Shape-module--jEmo8\",\"size-85x\":\"size-85x--Shape-module--_CUOW\",\"size-86x\":\"size-86x--Shape-module--t9p9T\",\"size-87x\":\"size-87x--Shape-module--ptVz5\",\"size-88x\":\"size-88x--Shape-module--wdl05\",\"size-89x\":\"size-89x--Shape-module--yWuxN\",\"size-90x\":\"size-90x--Shape-module--Bgdmv\",\"size-91x\":\"size-91x--Shape-module--JCT4Y\",\"size-92x\":\"size-92x--Shape-module--j9Q9P\",\"size-93x\":\"size-93x--Shape-module--s6fVA\",\"size-94x\":\"size-94x--Shape-module--MBVlQ\",\"size-95x\":\"size-95x--Shape-module--_D1EA\",\"size-96x\":\"size-96x--Shape-module--pAwk5\",\"size-97x\":\"size-97x--Shape-module--iwdUZ\",\"size-98x\":\"size-98x--Shape-module--ps6ad\",\"size-99x\":\"size-99x--Shape-module--Ycp9g\",\"size-100x\":\"size-100x--Shape-module--ZIHIu\",\"size-auto\":\"size-auto--Shape-module--iBYT1\",\"size-half\":\"size-half--Shape-module--h31oO\",\"size-full\":\"size-full--Shape-module--mgvUd\",\"size-fit-content\":\"size-fit-content--Shape-module--x05NF\",\"size-max-content\":\"size-max-content--Shape-module--Ad3wu\",\"type-circle\":\"type-circle--Shape-module--wbcGo\",\"type-square\":\"type-square--Shape-module--nqV8H\",\"width-100\":\"width-100--Shape-module--NDF0U\",\"width-75\":\"width-75--Shape-module--Pck2R\",\"width-66\":\"width-66--Shape-module--tMpFy\",\"width-50\":\"width-50--Shape-module--YgSEZ\",\"width-33\":\"width-33--Shape-module--lyfEb\",\"width-25\":\"width-25--Shape-module--R47Ey\",\"width-15\":\"width-15--Shape-module--YbJ2Q\",\"width-10\":\"width-10--Shape-module--e_dMo\",\"background-primary\":\"background-primary--Shape-module--gQui3\",\"background-secondary\":\"background-secondary--Shape-module--HlLFD\",\"background-tertiary\":\"background-tertiary--Shape-module--m3ckH\",\"background-gray-light\":\"background-gray-light--Shape-module--JjBL1\",\"background-white\":\"background-white--Shape-module--ffLJd\"};","import React, { HTMLAttributes } from \"react\";\nimport clsx from \"clsx\";\nimport styles from \"./Shape.module.scss\";\nimport { baseSizeList } from \"./BaseElement\";\n\nexport interface ShapeProps extends HTMLAttributes<HTMLDivElement> {\n\tclassName?: string;\n\ttype?: \"default\" | \"circle\" | \"square\";\n\tbackground?: \"primary\" | \"secondary\" | \"tertiary\" | \"gray-light\" | \"white\";\n\twidth?: \"0\" | \"10\" | \"15\" | \"25\" | \"33\" | \"50\" | \"66\" | \"75\" | \"100\";\n\theight?:\n\t\t| \"0\"\n\t\t| \"025x\"\n\t\t| \"05x\"\n\t\t| \"1x\"\n\t\t| \"2x\"\n\t\t| \"3x\"\n\t\t| \"4x\"\n\t\t| \"5x\"\n\t\t| \"6x\"\n\t\t| \"7x\"\n\t\t| \"8x\"\n\t\t| \"9x\"\n\t\t| \"10x\"\n\t\t| \"11x\"\n\t\t| \"12x\"\n\t\t| \"half\"\n\t\t| \"full\";\n\tsize?: baseSizeList;\n\tchildren?: React.ReactNode;\n}\n\nexport const Shape = ({ type, background, width, height, size, className, ...props }: ShapeProps) => {\n\tconst classList = clsx([\n\t\tstyles.shape,\n\t\tclassName,\n\t\ttype && styles[`type-${type}`],\n\t\twidth && styles[`width-${width}`],\n\t\theight && styles[`height-${height}`],\n\t\tsize && styles[`size-${size}`],\n\t\tbackground && styles[`background-${background}`],\n\t]);\n\n\treturn (\n\t\t<mark {...props} className={classList}>\n\t\t\t{props.children}\n\t\t</mark>\n\t);\n};\n","// extracted by mini-css-extract-plugin\nexport default {\"card\":\"card--Card-module--Uyq2w\",\"cardHeader\":\"cardHeader--Card-module--KR0v2\",\"hasBorder\":\"hasBorder--Card-module--fxYfh\",\"variant-default\":\"variant-default--Card-module--g7XUM\",\"variant-primary\":\"variant-primary--Card-module--QvHlL\",\"variant-secondary\":\"variant-secondary--Card-module--TZL4I\",\"variant-tertiary\":\"variant-tertiary--Card-module--MeoID\",\"variant-info\":\"variant-info--Card-module--LF5jl\",\"variant-success\":\"variant-success--Card-module--i1MEK\",\"variant-warning\":\"variant-warning--Card-module--mZDMj\",\"variant-error\":\"variant-error--Card-module--cY7fx\",\"variant-gray\":\"variant-gray--Card-module--nAbrt\",\"variant-support\":\"variant-support--Card-module--zrD61\",\"align-left\":\"align-left--Card-module--wnLc1\",\"align-center\":\"align-center--Card-module--tfOmc\",\"align-right\":\"align-right--Card-module--ngsY_\",\"show-pointer-cursor\":\"show-pointer-cursor--Card-module--Rsy24\",\"border-color-transparent\":\"border-color-transparent--Card-module--BayHs\",\"border-color-default\":\"border-color-default--Card-module--cC3NR\",\"border-color-black\":\"border-color-black--Card-module--iFKoK\",\"border-color-gray\":\"border-color-gray--Card-module--XrDK3\",\"border-color-gray-light\":\"border-color-gray-light--Card-module--DjAJe\",\"border-color-white\":\"border-color-white--Card-module--EbA3y\",\"border-color-primary\":\"border-color-primary--Card-module--lDmwz\",\"border-color-primary-lighter\":\"border-color-primary-lighter--Card-module--PWEco\",\"border-color-secondary\":\"border-color-secondary--Card-module--Dm1wi\",\"border-color-secondary-lighter\":\"border-color-secondary-lighter--Card-module--ow2wp\",\"border-color-secondary-lightest\":\"border-color-secondary-lightest--Card-module--xQmjd\",\"border-color-tertiary\":\"border-color-tertiary--Card-module--sNCiO\",\"border-color-info\":\"border-color-info--Card-module--gsHPD\",\"border-radius-default\":\"border-radius-default--Card-module--hkxMo\",\"border-radius-big\":\"border-radius-big--Card-module--t7eDs\",\"border-radius-small\":\"border-radius-small--Card-module--pF1HA\",\"border-radius-tiny\":\"border-radius-tiny--Card-module--WIMNZ\",\"border-radius-none\":\"border-radius-none--Card-module--aDbIo\",\"border-style-solid\":\"border-style-solid--Card-module--drMTe\",\"border-style-dashed\":\"border-style-dashed--Card-module--__PvI\",\"background-color-transparent\":\"background-color-transparent--Card-module--MEuFZ\",\"background-color-default\":\"background-color-default--Card-module--kciJK\",\"background-color-blend\":\"background-color-blend--Card-module--LuXHf\",\"background-color-black\":\"background-color-black--Card-module--xYl8e\",\"background-color-gray\":\"background-color-gray--Card-module--_PA0B\",\"background-color-white\":\"background-color-white--Card-module--Pw92p\",\"background-color-primary\":\"background-color-primary--Card-module--H49KC\",\"background-color-primary-lighter\":\"background-color-primary-lighter--Card-module--Jv8oL\",\"background-color-secondary\":\"background-color-secondary--Card-module--nCzC0\",\"background-color-secondary-lighter\":\"background-color-secondary-lighter--Card-module--XQnJv\",\"background-color-secondary-lightest\":\"background-color-secondary-lightest--Card-module--QKxXx\",\"background-color-tertiary\":\"background-color-tertiary--Card-module--Hf3hM\"};","import clsx from \"clsx\";\nimport React, { forwardRef } from \"react\";\nimport { BaseElement, BaseElementProps } from \"./BaseElement\";\nimport styles from \"./Card.module.scss\";\n\nexport interface CardProps extends BaseElementProps {\n\tclassName?: string;\n\tvariant?:\n\t\t| \"primary\"\n\t\t| \"secondary\"\n\t\t| \"tertiary\"\n\t\t| \"info\"\n\t\t| \"success\"\n\t\t| \"warning\"\n\t\t| \"error\"\n\t\t| \"gray\"\n\t\t| \"support\"\n\t\t| \"default\";\n\tborderRadius?: \"default\" | \"big\" | \"small\" | \"tiny\" | \"none\";\n\tborderColor?:\n\t\t| \"transparent\"\n\t\t| \"default\"\n\t\t| \"black\"\n\t\t| \"gray\"\n\t\t| \"gray-light\"\n\t\t| \"white\"\n\t\t| \"info\"\n\t\t| \"primary\"\n\t\t| \"primary-lighter\"\n\t\t| \"secondary\"\n\t\t| \"secondary-lighter\"\n\t\t| \"tertiary\";\n\tborderStyle?: \"solid\" | \"dashed\";\n\talign?: \"left\" | \"center\" | \"right\";\n\tchildren?: React.ReactNode;\n}\n\nconst Card = forwardRef<HTMLDivElement, CardProps>(\n\t({ align, variant = \"default\", borderRadius, borderColor, borderStyle, className, ...props }, ref) => {\n\t\tconst classList = clsx([\n\t\t\tstyles.card,\n\t\t\tclassName,\n\t\t\tvariant && styles[`variant-${variant}`],\n\t\t\tborderRadius && styles[`border-radius-${borderRadius}`],\n\t\t\tborderColor && styles[`border-color-${borderColor}`],\n\t\t\tborderStyle && styles[`border-style-${borderStyle}`],\n\t\t\talign && styles[`align-${align}`],\n\t\t\tprops.onClick && styles[\"show-pointer-cursor\"],\n\t\t]);\n\n\t\treturn (\n\t\t\t<BaseElement {...props} className={classList} ref={ref}>\n\t\t\t\t{props.children}\n\t\t\t</BaseElement>\n\t\t);\n\t}\n);\n\nCard.displayName = \"Card\";\n\nexport interface CardHeaderProps extends BaseElementProps {\n\tclassName?: string;\n\tborder?: string;\n\tchildren?: React.ReactNode;\n}\n\nconst CardHeader = ({ border, className, ...props }: CardHeaderProps) => {\n\tconst classList = clsx([\n\t\tstyles.cardHeader,\n\t\tclassName,\n\t\tborder && styles.hasBorder,\n\t\tprops.onClick && styles[\"show-pointer-cursor\"],\n\t]);\n\n\treturn (\n\t\t<BaseElement {...props} className={classList} style={{ borderTopColor: border }}>\n\t\t\t{props.children}\n\t\t</BaseElement>\n\t);\n};\n\nexport { Card, CardHeader };\n"],"names":["Text","React","loading","isLiquid","underline","italic","multiline","truncate","align","variant","fontStyle","weight","family","color","transform","className","props","ref","cssClasses","clsx","styles","text","onClick","BaseElement","children","displayName","defaultOptions","SeEmployeeDataRoleChoices","SeCakeGroupGroupTypeChoices","SalesLicenseCakePlanChoices","OrganisationsValuationRoundChoices","OrganisationsOrganisationCurrencyChoices","NotesroundsNotesRoundOfferStatusChoices","IdentifierType","EsopEsopOfferNextVestingMetaChoices","CustomerIoMailTemplates","ContractType","CommentModelTypeEnum","BoardapprovalsBoardApprovalStatusChoices","AddonType","InternationalUsCompanyDetailsStateOfRegistrationChoices","DocumentsDocumentTypeChoices","CompanyRole","GlobalTeams","Qsbs","Valuation_409A","Done","Waiting","Esop","EsopTransaction","Ess","EssTransaction","Rsu","RsuTransaction","SharesTransaction","AuthorisedSigner","Both","Director","Officer","President","Secretary","CompanyRoleOutputField","BareTrustDeed","BeneficialHoldings","BlankContract","BoardApproval","ConvertibleNote","ConvertibleNoteLlc","DirectorsResolution","ExerciseNotice","GlobalOfferLetter","GlobalOfferLetterEss","GlobalOfferLetterRsu","NoteDeedOfAccession","NoteNoticeOfConversion","OfferLetter","OfferLetterEss","OfferLetterFoundervesting","OfferLetterPhantom","OfferLetterRsu","OfferLetterWarrant","PlanRules","PlanRulesEss","PlanRulesFoundervesting","PlanRulesPhantom","PlanRulesRsu","PlanRulesWarrant","SafeNote","SafeNoteLlc","ShareholdersResolution","ShareCertificate","ShareCertificateTransactional","ShareTransferAgreement","SubscriptionAgreement","AnnualRenewalReminder","AutoVestingEmail","EarlyExerciseEmail","EarlyExerciseReminderWithoutForm","EarlyExerciseReminderWithForm","EmployeePortalWelcome","ExerciseRequestApproval","FreeCaptableUpload","MilestoneReminder","NewDefaultTemplate","NewMessageNotification","NewReplyNotification","Request_409A","SendKudos","UserInvite","UserInviteReminder","VestingPlanOfferInvite","File","Folder","Processing","Template","DocumentsScanbotDocumentStatusChoices","Error","Success","EquityRoundNoteConversionOutputField","Automatic","Manual","NoConversion","EquityRoundTypeOutputField","Notes","Priced","EsopEsopOfferExerciseExpirationStartingPointChoices","GrantDate","VestStartDate","FullyVesting","MeetingMilestone","PeriodicVesting","ReachingCliff","Unknown","EsopEsopOfferOptionTypeChoices","Iso","Nso","EsopEsopTransactionTypeChoices","Exercised","Granted","Lapsed","Repriced","Vested","EsopOptionExerciseRequestStatusChoices","Completed","Declined","ReadyToIssue","ReadyToPay","Requested","EssEssOfferNextVestingMetaChoices","EssEssTransactionTypeChoices","FoundervestingFounderVestingOfferNextVestingMetaChoices","FoundervestingFounderVestingTransactionTypeChoices","HoldingsType","Beneficiaries","Contacts","Noteholders","Optionholders","Rsuholders","Shareholders","ShareVestHolders","Abn","Acn","Bn","Brc","Cin","Crn","Ein","Nzbn","Other","Uen","IdentifierTypeOutputField","Ak","Al","Ar","As","Az","Ca","Co","Ct","Dc","De","Fl","Fm","Ga","Gu","Hi","Ia","Id","Il","In","Ks","Ky","La","Ma","Md","Me","Mh","Mi","Mn","Mo","Mp","Ms","Mt","Nc","Nd","Ne","Nh","Nj","Nm","Nv","Ny","Oh","Ok","Or","Pa","Pr","Pw","Ri","Sc","Sd","Tn","Tx","Ut","Va","Vi","Vt","Wa","Wi","Wv","Wy","MessageStatus","Draft","Received","Sent","NoteConversionEnum","NoteType","Convertible","Custom","Safe","NotesNoteInterestAccrualMethodChoices","Compounding","Simple","NotesNoteResolutionChoices","Cancelled","Converted","Dissolved","Paid","NotesNoteTransactionTypeChoices","Cancel","Convert","Dissolve","Issue","Repay","NotesNoteTypeChoices","NotesroundsNotesRoundInterestAccrualMethodChoices","NotesroundsNotesRoundNoteTypeChoices","NotesroundsNotesRoundOfferInterestAccrualMethodChoices","NoteIssued","ReadyToAccept","ReadyToConfirmDetails","ReadyToSign","ReadyToStart","OffboardingModelTypeEnum","Foundervesting","OffboardingStatus","Scheduled","OrganisationsOrganisationCompanySizeChoices","A_1_5","A_6_10","A_11_20","A_21_50","A_51_100","A_100","OrganisationsOrganisationCompanyTypeChoices","CCorp","Incorporation","Llc","Llp","NonProfit","SoleProprietorship","SCorp","OrganisationsOrganisationCreationIntentChoices","Captable","None","Plans","OrganisationsOrganisationCreatorRoleChoices","Executive","FirstTimeFounder","RepeatFounder","ServiceProvider","Aed","Afn","All","Amd","Ang","Aoa","Ars","Aud","Awg","Azn","Bam","Bbd","Bdt","Bgn","Bhd","Bif","Bmd","Bnd","Bob","Bov","Brl","Bsd","Btn","Bwp","Byn","Bzd","Cad","Cdf","Che","Chf","Chw","Clf","Clp","Cny","Cop","Cou","Crc","Cuc","Cup","Cve","Czk","Djf","Dkk","Dop","Dzd","Egp","Ern","Etb","Eur","Fjd","Fkp","Gbp","Gel","Ghs","Gip","Gmd","Gnf","Gtq","Gyd","Hkd","Hnl","Hrk","Htg","Huf","Idr","Ils","Inr","Iqd","Irr","Isk","Jmd","Jod","Jpy","Kes","Kgs","Khr","Kmf","Kpw","Krw","Kwd","Kyd","Kzt","Lak","Lbp","Lkr","Lrd","Lsl","Lyd","Mad","Mdl","Mga","Mkd","Mmk","Mnt","Mop","Mru","Mur","Mvr","Mwk","Mxn","Mxv","Myr","Mzn","Nad","Ngn","Nio","Nok","Npr","Nzd","Omr","Pab","Pen","Pgk","Php","Pkr","Pln","Pyg","Qar","Ron","Rsd","Rub","Rwf","Sar","Sbd","Scr","Sdg","Sek","Sgd","Shp","Sle","Sll","Sos","Srd","Ssp","Stn","Svc","Syp","Szl","Thb","Tjs","Tmt","Tnd","Top","Try","Ttd","Twd","Tzs","Uah","Ugx","Usd","Uyi","Uyu","Uyw","Uzs","Ves","Vnd","Vuv","Wst","Xaf","Xcd","Xof","Xpf","Yer","Zar","Zmw","Zwl","OrganisationsOrganisationExperienceLevelChoices","Beginner","Experienced","OrganisationsOrganisationShareCertificateTypeChoices","ShareCertificateHoldings","OrganisationsOrganisationUserRolePositionChoices","Attorney","Cofounder","Finance","Hr","OrganisationsOrganisationUserRoleRoleChoices","Admin","Advisor","Edit","Support","View","OrganisationsOrganisationValuationRequestStatusChoices","NoValuationRequested","ValuationComplete","ValuationInProgress","ValuationRequested","PreSeed","PreSeedBridging","Seed","SeedBridging","SeriesA","SeriesABridging","SeriesB","SeriesBBridging","SeriesC","SeriesCBridging","SeriesD","RoundTypeEnum","RsuRsuOfferNextVestingMetaChoices","RsuRsuTransactionTypeChoices","Csfgrowth_5M_5","Csfgrowth_5Q_5","Csfgrowth_5Y_5","Csfpro_5M_5","Csfpro_5Q_5","Csfpro_5Y_5","Csfstarter_5M_5","Csfstarter_5Q_5","Csfstarter_5Y_5","Free_0M","Global_5M","Global_5Y","Growth_2M","Growth_2Y","Growth_3M","Growth_3Y","Growth_4M","Growth_4Y","Growth_5M","Growth_5M_5","Growth_5Q_5","Growth_5Y","Growth_5Y_5","Pro_5M_5","Pro_5Q_5","Pro_5Y_5","Starter_2M","Starter_2Y","Starter_3M","Starter_3Y","Starter_4M","Starter_4Y","Starter_5M","Starter_5M_5","Starter_5Q_5","Starter_5Y","Starter_5Y_5","Noteholder","Notesrounds","Officeholder","Optionholder","Organisation","Raise","Shareholder","Sharetransferrounds","Sharetype","Warrant","SeEmailSenderEntryTypeChoices","Digest","DigestSend","Invite","Onboarding","SeEmployeeDataLevelChoices","Ceo","Junior","MidLevel","Senior","CustomerSuccess","Data","Design","Engineering","Founder","MarketingGrowth","Product","SalesBd","StrategyOperations","TalentPeople","SeOffboardEventSettingsStopVestingAtChoices","AfterPtep","OffboardDate","SeOfficeholderRoleRoleChoices","Alt","Dir","Ofc","Prs","Sec","SeOfficeholderSignerChoices","Primary","Secondary","SeOrganisationRaiseOfferStatusChoices","SharesIssued","SeShareholdingTransactionTypeChoices","BuyBack","Conversion","Import","ShareSplit","ShareSplitComplete","Transfer","TransfersShareTransferOfferStatusChoices","ReadyToTransfer","SharesTransferred","Unit","Days","Hours","Minutes","Months","Seconds","Years","UserAccountsUserSettingsCurrencyChoices","VestingGranularity","VestingGranularityOutputField","VestingPlanType","Phantom","WarrantWarrantOfferExerciseExpirationStartingPointChoices","WarrantWarrantOfferNextVestingMetaChoices","WarrantWarrantTransactionTypeChoices","OrganisationDetailsDocument","gql","useOrganisationDetailsLazyQuery","baseOptions","options","Apollo","UserOrganisationStatusDocument","useUserOrganisationStatusQuery","SendEmployeeLicenseBlockEmailDocument","useSendEmployeeLicenseBlockEmailMutation","DocumentsHomeDocument","useDocumentsHomeQuery","HomeEntrypointDocument","useHomeEntrypointLazyQuery","UserOrganisationsDocument","useUserOrganisationsLazyQuery","HomeDocumentsDocument","useHomeDocumentsLazyQuery","HomeMessagesDocument","useHomeMessagesLazyQuery","HomePortfolioDocument","useHomePortfolioLazyQuery","HomeOffersPendingDocument","useHomeOffersPendingLazyQuery","UserEmployeeGoalDocument","useUserEmployeeGoalLazyQuery","VestingCliffDocument","useVestingCliffLazyQuery","HomeOffersEarningChartDocument","useHomeOffersEarningChartLazyQuery","SetUserEmployeeGoalDocument","useSetUserEmployeeGoalMutation","InvestorInboxDocument","useInvestorInboxQuery","InvestorMessageThreadDocument","useInvestorMessageThreadQuery","useInvestorMessageThreadLazyQuery","MessageReactionUpdateDocument","useMessageReactionUpdateMutation","OffersHomeDocument","useOffersHomeQuery","SendKudosDocument","useSendKudosMutation","ForceUpdateSigningStatusDocument","useForceUpdateSigningStatusMutation","OffersDetailsEsopDocument","useOffersDetailsEsopQuery","ConfirmOfferInvestorDetailsEsopDocument","useConfirmOfferInvestorDetailsEsopMutation","DeclineOfferEsopDocument","useDeclineOfferEsopMutation","SignOfferLetterEsopDocument","useSignOfferLetterEsopMutation","OffersDetailsEssDocument","useOffersDetailsEssQuery","ConfirmOfferInvestorDetailsEssDocument","useConfirmOfferInvestorDetailsEssMutation","DeclineOfferEssDocument","useDeclineOfferEssMutation","SignOfferLetterEssDocument","useSignOfferLetterEssMutation","OffersDetailsRaiseEquityDocument","useOffersDetailsRaiseEquityQuery","ConfirmEquityOfferInvestorDetailsDocument","useConfirmEquityOfferInvestorDetailsMutation","DeclineEquityOfferDocument","useDeclineEquityOfferMutation","AcceptEquityOfferDocument","useAcceptEquityOfferMutation","SignSubscriptionAgreementDocument","useSignSubscriptionAgreementMutation","OffersDetailsRaiseNotesDocument","useOffersDetailsRaiseNotesQuery","ConfirmNotesOfferInvestorDetailsDocument","useConfirmNotesOfferInvestorDetailsMutation","DeclineNotesOfferDocument","useDeclineNotesOfferMutation","AcceptNotesOfferDocument","useAcceptNotesOfferMutation","SignNoteAgreementDocument","useSignNoteAgreementMutation","OffersDetailsRsuDocument","useOffersDetailsRsuQuery","ConfirmOfferInvestorDetailsRsuDocument","useConfirmOfferInvestorDetailsRsuMutation","DeclineOfferRsuDocument","useDeclineOfferRsuMutation","SignOfferLetterRsuDocument","useSignOfferLetterRsuMutation","OffersDetailsTransfersDocument","useOffersDetailsTransfersQuery","ConfirmShareTransferOfferInvestorDetailsDocument","useConfirmShareTransferOfferInvestorDetailsMutation","DeclineShareTransferOfferDocument","useDeclineShareTransferOfferMutation","SignShareTransferAgreementDocument","useSignShareTransferAgreementMutation","PortfolioOfferDetailsEsopDocument","usePortfolioOfferDetailsEsopLazyQuery","PortfolioOffersListEsopDocument","usePortfolioOffersListEsopQuery","RequestExerciseDocument","useRequestExerciseMutation","CanRequestExerciseDocument","useCanRequestExerciseLazyQuery","PrepareRequestExerciseDocument","usePrepareRequestExerciseQuery","GetExerciseRequestDocument","useGetExerciseRequestQuery","ExerciseRequestsFromOfferDocument","useExerciseRequestsFromOfferLazyQuery","SubmitExercisePaymentDocument","useSubmitExercisePaymentMutation","PortfolioOffersListEssFounderVestingDocument","usePortfolioOffersListEssFounderVestingQuery","PortfolioOfferDetailsEssFounderVestingDocument","usePortfolioOfferDetailsEssFounderVestingLazyQuery","PortfolioHomeDocument","usePortfolioHomeQuery","PortfolioShareDetailsDocument","usePortfolioShareDetailsQuery","PortfolioBeneficialHoldingsDetailsDocument","usePortfolioBeneficialHoldingsDetailsQuery","PortfolioDetailsDocument","usePortfolioDetailsQuery","PortfolioNoteDetailsDocument","usePortfolioNoteDetailsQuery","PortfolioOfferDetailsRsuDocument","usePortfolioOfferDetailsRsuLazyQuery","PortfolioOffersListRsuDocument","usePortfolioOffersListRsuQuery","PortfolioOfferDetailsWarrantDocument","usePortfolioOfferDetailsWarrantLazyQuery","PortfolioOffersListWarrantDocument","usePortfolioOffersListWarrantQuery","CanChangeEmailDocument","useCanChangeEmailLazyQuery","SkipUserOnboardingDocument","useSkipUserOnboardingMutation","RequestEmailChangeDocument","useRequestEmailChangeMutation","UpdateUserOnboardingDocument","useUpdateUserOnboardingMutation","AcceptTermsAndConditionsDocument","useAcceptTermsAndConditionsMutation","ShareholderDetailsDocument","useShareholderDetailsLazyQuery","GetActionsDocument","useGetActionsQuery","GetReminderEmailDocument","useGetReminderEmailLazyQuery","RemindAllOffersDocument","useRemindAllOffersMutation","TouchOffersDocument","useTouchOffersMutation","GetActivityLogEntriesDocument","useGetActivityLogEntriesQuery","GetInvoicesDocument","useGetInvoicesQuery","GetLicenseForBillingDocument","useGetLicenseForBillingLazyQuery","GetBillingStakeholdersDocument","useGetBillingStakeholdersQuery","OverrideDelinquentLockDocument","useOverrideDelinquentLockMutation","ResumeSubscriptionDocument","useResumeSubscriptionMutation","SendChurnDiscountRequestDocument","useSendChurnDiscountRequestMutation","GetPlanNamesEsopDocument","useGetPlanNamesEsopQuery","GetOrganisationBoardMembersDataDocument","useGetOrganisationBoardMembersDataQuery","CreateBoardApprovalDocument","useCreateBoardApprovalMutation","DeleteBoardApprovalDocument","useDeleteBoardApprovalMutation","SendBoardApprovalReminderDocument","useSendBoardApprovalReminderMutation","BoardApprovalsDocument","useBoardApprovalsQuery","BoardApprovalDetailsDocument","useBoardApprovalDetailsQuery","GetOrganisationAvailableBoardMembersRolesDocument","useGetOrganisationAvailableBoardMembersRolesQuery","AddOBoardMemberDocument","useAddOBoardMemberMutation","GetCommentsDocument","useGetCommentsQuery","DeleteCommentDocument","useDeleteCommentMutation","CreateCommentDocument","useCreateCommentMutation","SbcOffersDocument","useSbcOffersQuery","SendAsc718RequestDocument","useSendAsc718RequestMutation","QsbsTransactionsDocument","useQsbsTransactionsQuery","GenerateQsbsReportForTransactionsDocument","useGenerateQsbsReportForTransactionsMutation","EchoPublicDocument","EchoPrivateDocument","DebugClearDailyVestCacheDocument","DebugCacheStatisticsDocument","DebugInvalidateCacheDocument","DebugTriggerEndedDisclosuresDocument","DebugInvalidateStripePlanCacheDocument","DebugRefreshLicenseDocument","useDebugRefreshLicenseMutation","DebugReportUsageDocument","DebugConsolidateCapTableDocument","DebugEsopCalendarDocument","DebugEssCalendarDocument","DebugRefreshExchangeRatesDocument","TemplatesByContractTypeDocument","useTemplatesByContractTypeQuery","GetContractLinkDocument","useGetContractLinkQuery","useGetContractLinkLazyQuery","CreateFolderDocument","useCreateFolderMutation","DeleteDocumentDocument","useDeleteDocumentMutation","RenameDocumentDocument","useRenameDocumentMutation","UploadToScanbotDocument","useUploadToScanbotMutation","GetTemplatesByContractTypeDocument","useGetTemplatesByContractTypeQuery","GetPlanToEditEsopDocument","useGetPlanToEditEsopQuery","GetPlanOfferToEditOptionPriceEsopDocument","useGetPlanOfferToEditOptionPriceEsopQuery","GetPlanOfferToEditExercisePriceEsopDocument","useGetPlanOfferToEditExercisePriceEsopQuery","GetPlanOfferToEditGrantDateEsopDocument","useGetPlanOfferToEditGrantDateEsopQuery","GetPlanOfferToEditExpireDateEsopDocument","useGetPlanOfferToEditExpireDateEsopQuery","GetPlanOfferToEditVestingEventsEsopDocument","useGetPlanOfferToEditVestingEventsEsopQuery","CheckOffersPostGrantGrantDateEditabilityEsopDocument","useCheckOffersPostGrantGrantDateEditabilityEsopQuery","CheckOffersPostGrantOptionPriceEditabilityEsopDocument","useCheckOffersPostGrantOptionPriceEditabilityEsopQuery","CheckOffersPostGrantExercisePriceEditabilityEsopDocument","useCheckOffersPostGrantExercisePriceEditabilityEsopQuery","CheckOffersPostGrantExpirationEditabilityEsopDocument","useCheckOffersPostGrantExpirationEditabilityEsopQuery","CheckOffersBulkPostGrantPtepEditabilityEsopDocument","useCheckOffersBulkPostGrantPtepEditabilityEsopQuery","CheckOfferPostGrantPtepEditabilityEsopDocument","useCheckOfferPostGrantPtepEditabilityEsopQuery","EditPostGrantDateEsopDocument","useEditPostGrantDateEsopMutation","EditPostVestDateEsopDocument","useEditPostVestDateEsopMutation","EditPostGrantOptionPriceEsopDocument","useEditPostGrantOptionPriceEsopMutation","EditPostGrantExercisePriceEsopDocument","useEditPostGrantExercisePriceEsopMutation","EditPostGrantExpirationEsopDocument","useEditPostGrantExpirationEsopMutation","EditPostGrantPtepEsopDocument","useEditPostGrantPtepEsopMutation","EditEsopDocument","useEditEsopMutation","EditGroupAndEsopDocument","useEditGroupAndEsopMutation","DeleteEsopDocument","useDeleteEsopMutation","GetDataToLapseOfferEsopDocument","useGetDataToLapseOfferEsopQuery","GetOffersEligibleForApprovalEsopDocument","useGetOffersEligibleForApprovalEsopLazyQuery","LapseOfferMilestoneEsopDocument","useLapseOfferMilestoneEsopMutation","LapseOfferEsopDocument","useLapseOfferEsopMutation","FullyLapseOfferEsopDocument","useFullyLapseOfferEsopMutation","GetPlanToEditEssDocument","useGetPlanToEditEssQuery","EditEssDocument","useEditEssMutation","EditGroupAndEssDocument","useEditGroupAndEssMutation","DeleteEssDocument","useDeleteEssMutation","Update83bFormDownloadStatusDocument","useUpdate83bFormDownloadStatusMutation","GetMessageAnalyticsDocument","useGetMessageAnalyticsQuery","SendMessageDocument","useSendMessageMutation","SaveMessageDocument","useSaveMessageMutation","DeleteMessageDocument","useDeleteMessageMutation","UpdateMessageAnalyticsDocument","useUpdateMessageAnalyticsMutation","ToggleMessageAllowRepliesDocument","useToggleMessageAllowRepliesMutation","ToggleOrganisationAllowRepliesDocument","useToggleOrganisationAllowRepliesMutation","OrganisationInboxDocument","useOrganisationInboxQuery","OrganisationAllowMessageRepliesDocument","useOrganisationAllowMessageRepliesQuery","OrganisationMessageThreadDocument","useOrganisationMessageThreadQuery","GetShareholdersForAutocompleteDocument","useGetShareholdersForAutocompleteQuery","CreateEquityModelDocument","EditEquityModelDocument","DeleteEquityModelDocument","EquityModelsDocument","NotesOffersDocument","useNotesOffersQuery","NotesOfferDocument","useNotesOfferQuery","GetStakeholdersToAddNoteDocument","useGetStakeholdersToAddNoteQuery","GetNotesRoundsNamesDocument","useGetNotesRoundsNamesQuery","GetNotesRoundsDocument","useGetNotesRoundsQuery","CreateNotesOfferDocument","useCreateNotesOfferMutation","EditNotesOfferDocument","useEditNotesOfferMutation","CreateTemplateNoteDocument","useCreateTemplateNoteMutation","SetNotesRoundTemplateDocument","useSetNotesRoundTemplateMutation","SetNotesOfferTemplateDocument","useSetNotesOfferTemplateMutation","CreateNotesOfferTemplateDocument","useCreateNotesOfferTemplateMutation","GetMasterTemplateViewLinkDocument","useGetMasterTemplateViewLinkQuery","GetNoteOfferToConvertDocument","useGetNoteOfferToConvertQuery","GetNoteOfferToInviteDocument","useGetNoteOfferToInviteQuery","GetNoteOfferToEditDocument","useGetNoteOfferToEditQuery","DeleteNotesRoundOfferDocument","useDeleteNotesRoundOfferMutation","ResetNotesRoundOfferDocument","useResetNotesRoundOfferMutation","UpdateNotesOfferPaymentStatusDocument","useUpdateNotesOfferPaymentStatusMutation","InviteNotesOfferDocument","useInviteNotesOfferMutation","SettleNotesOfferOfflineDocument","useSettleNotesOfferOfflineMutation","ConvertNoteDocument","useConvertNoteMutation","ConvertNoteManualDocument","useConvertNoteManualMutation","CancelNoteDocument","useCancelNoteMutation","GetOffboardingsDocument","useGetOffboardingsQuery","CreateOffboardingDocument","useCreateOffboardingMutation","DeleteOffboardingDocument","useDeleteOffboardingMutation","ShareholdersToOffboardDocument","useShareholdersToOffboardQuery","ShareholderOffboardingOffersDocument","useShareholderOffboardingOffersLazyQuery","OffboardingDetailsEsopDocument","useOffboardingDetailsEsopQuery","OffboardingDetailsEssDocument","useOffboardingDetailsEssQuery","OffboardingDetailsRsuDocument","useOffboardingDetailsRsuQuery","OffboardingDetailsFounderVestingDocument","useOffboardingDetailsFounderVestingQuery","OffboardingDocument","useOffboardingQuery","EditOffboardingDocument","useEditOffboardingMutation","AddShareholderIssueSharesDocument","useAddShareholderIssueSharesMutation","OnboardingShownDocument","useOnboardingShownMutation","GetStepAddShareholdersDataDocument","useGetStepAddShareholdersDataQuery","GetOrganisationDataDocument","GetOrganisationSharetypesAndTotalsDocument","CreateOrganisationSignupDocument","useCreateOrganisationSignupMutation","GetUserOrganisationsDocument","useGetUserOrganisationsQuery","useGetUserOrganisationsLazyQuery","InviteJoinCakeDocument","useInviteJoinCakeMutation","SendTestTransactionalEmailDocument","useSendTestTransactionalEmailMutation","ClearUserInviteSenderDocument","useClearUserInviteSenderMutation","GetCakeGroupsWithShareholdersDocument","useGetCakeGroupsWithShareholdersQuery","HasPendingActionsDocument","useHasPendingActionsLazyQuery","PlatformVersionDocument","GetValuationsDocument","useGetValuationsQuery","Send409aProviderNotificationDocument","useSend409aProviderNotificationMutation","UpdateOneTimeAddonStatusDocument","useUpdateOneTimeAddonStatusMutation","GetCakePlansV5Document","useGetCakePlansV5Query","BuyOneOff409ADocument","UpdateCreditCardDocument","PayPendingInvoicesDocument","PauseSubscriptionDocument","usePauseSubscriptionMutation","RequestCancelSubscriptionDocument","useRequestCancelSubscriptionMutation","GetStripeCustomerIdDocument","useGetStripeCustomerIdLazyQuery","UpdateVisibilitySettingsDocument","useUpdateVisibilitySettingsMutation","GetCopilotOnboardingDataDocument","useGetCopilotOnboardingDataQuery","RevertCancelSubscriptionDocument","PaginatedShareholdersDocument","usePaginatedShareholdersQuery","GetShareholdersToEditTransactionsDocument","useGetShareholdersToEditTransactionsQuery","DeleteShareholdersDocument","useDeleteShareholdersMutation","EditOnboardedShareholdersDocument","useEditOnboardedShareholdersMutation","GetUserPreferenceDocument","useGetUserPreferenceQuery","SetUserPreferenceDocument","useSetUserPreferenceMutation","GetMainMenuDataDocument","GetNeedsOnboardingDocument","useGetNeedsOnboardingQuery","GetBeginnerMenuDataDocument","useGetBeginnerMenuDataQuery","GetNotSignedUpStakeholdersDocument","useGetNotSignedUpStakeholdersQuery","GetPeopleDocument","useGetPeopleQuery","StakeholdersMergePreviewDocument","useStakeholdersMergePreviewQuery","MergeStakeholdersDocument","useMergeStakeholdersMutation","GetTeamDataToRequestExerciseDocument","useGetTeamDataToRequestExerciseQuery","SetupExerciseRequestSettingsDocument","useSetupExerciseRequestSettingsMutation","EditExerciseRequestSettingsDocument","useEditExerciseRequestSettingsMutation","ExerciseRequestSettingsDocument","useExerciseRequestSettingsQuery","HasExerciseRequestSettingsDocument","useHasExerciseRequestSettingsQuery","ExerciseRequestsDocument","useExerciseRequestsQuery","ApproveExerciseRequestDocument","useApproveExerciseRequestMutation","RejectExerciseRequestDocument","useRejectExerciseRequestMutation","ConfirmExercisePaymentAndIssueSharesDocument","useConfirmExercisePaymentAndIssueSharesMutation","GetDataToRequestExerciseSettleOffineDocument","useGetDataToRequestExerciseSettleOffineQuery","GetTrusteesToRequestExerciseDocument","useGetTrusteesToRequestExerciseQuery","SettleExerciseRequestOfflineDocument","useSettleExerciseRequestOfflineMutation","GetPlanToEditRsuDocument","useGetPlanToEditRsuQuery","EditRsuDocument","useEditRsuMutation","EditGroupAndRsuDocument","useEditGroupAndRsuMutation","DeleteRsuDocument","useDeleteRsuMutation","RefreshScanbotStatusDocument","useRefreshScanbotStatusMutation","DeleteScanbotDocumentDocument","useDeleteScanbotDocumentMutation","UploadEditableDocumentDocument","useUploadEditableDocumentMutation","ScanbotDocumentDocument","useScanbotDocumentQuery","ScanbotDocumentsDocument","useScanbotDocumentsQuery","List409aValuationsDocument","useList409aValuationsQuery","Get409aListDocument","useGet409aListQuery","AddHistorical409ADocument","useAddHistorical409AMutation","DeleteHistorical409ADocument","useDeleteHistorical409AMutation","ApplyHistorical409aStrikePriceDocument","GetVestingScheduleTemplatesDocument","useGetVestingScheduleTemplatesQuery","CreateVestingScheduleTemplateDocument","useCreateVestingScheduleTemplateMutation","EditVestingScheduleTemplateDocument","useEditVestingScheduleTemplateMutation","DeleteVestingScheduleTemplateDocument","useDeleteVestingScheduleTemplateMutation","GetPlanOffersWarrantsDocument","useGetPlanOffersWarrantsQuery","tracking_websocket","baseCakeTrack","event","getAppContext","APP_ENVIRONMENT","console","trace","alert","error","Promise","reject","utm_codes","searchParams","URLSearchParams","window","location","search","utm_source","get","utm_term","utm_medium","utm_content","utm_campaign","utm_source_last","utm_term_last","utm_medium_last","utm_content_last","utm_campaign_last","cta_platform","cta_location","cta_button","extractUtmCodes","platform","APP_SEGMENT","enrichedEvent","event_step","created_at","Date","toISOString","referrer","document","url","href","session_id","amplitude","getSessionId","target_platform","orgid","useOrgStore","getState","selectedOrgId","country","organisationData","log","data","resolve","readyState","addEventListener","WebSocket","protocol","host","onerror","warn","onclose","then","ws","send","JSON","stringify","catch","resources","en","llc","us","au","gb","initCakeI18n","i18n","lng","defaultNS","debug","translate","orgData","nameSpace","type","toLocaleLowerCase","ns","TOAST_DEFAULT_DURATION","toaster","toast","overlap","placement","Toast","toastProps","parentService","service","useMachine","parent","api","normalizeProps","memoizedInnerHtml","useMemo","__html","DOMPurify","sanitize","description","ALLOWED_TAGS","ALLOWED_ATTR","getRootProps","getGhostBeforeProps","getDescriptionProps","dangerouslySetInnerHTML","Button","icon","DynamicIcons","close","size","dismiss","getGhostAfterProps","Toaster","machine","id","useId","store","connect","getGroupProps","getToasts","map","key","ToastDismiss","queueMicrotask","ToastError","message","duration","create","title","ToastSuccess","ToastInfo","useToast","add","addCircle","alarm","attachment","arrowCircle","arrowsTriangle","arrow","arrowSort","barLineChart","cakeStroke","chat","checkBg","checkmark","checkEmpty","checkChecked","checkmarkCircle","chevron","comment","commentActive","copy","deleteIcon","documentAdd","documentAttachment","documentCheckmark","done","doneEggplant","doneGrey","download","edit","editSquare","eyeSlash","files","filters","filterStatus","help","info","infoFill","pieChart","puzzle","lineChart","minusCircle","more","move","notification","notificationAlert","refresh","signatureDraw","signatureDrawActive","signatureSelect","signatureSelectActive","shield","usersAdd","usersCheckmark","pen","pencil","menuQuickstart","menuDashboard","menuCaptable","menuPeople","menuEquity","menuDocuments","menuTools","menuBoardApprovals","menuCommunication","menuSettings","menuClock","menuLiquidityInterest","menuSupportAdmin","menuInbox","menuTodo","menuClipboard","filter","date","alertDynamic","alertTriangle","flag","table","settings","calculator","columns","certificate","closeCircle","thumbs","vest","vestStop","pause","resume","copyPaste","exercise","reset","reminder","offline","caret","time","userDashed","handsClapping","presentation","lifeBuoy","play","square","grid","scribble","user","userMultiple","fileArrowUp","gear","notePencil","starOutline","percentage","trendUp","currencyDollar","listMagnifyingGlass","checkmarkDashedCircle","drag","envelope","reply","tag","rocket","downgrade","lock","save","upload","DynamicMenuIcons","menuHeaderCaptable","menuHeaderCompliance","menuHeaderEngage","menuHeaderIncentives","menuHeaderGetStarted","menuHeaderSettings","menuHeaderTools","menuBeginnerGetStarted","menuBeginnerGroupsAndBoard","menuBeginnerSettings","menuBeginnerTeamHub","menuBeginnerToDo","menuBeginnerExerciseRequests","menuBeginnerOffBoarding","menuBeginnerPlans","menuBeginnerBoardApprovals","menuBeginnerVestingTemplates","menuBeginnerCapTable","menuBeginnerTransfers","menuBeginnerShareClasses","menuBeginnerTransactionLogs","menuBeginnerValuations","menuBeginner409a","menuBeginnerPeople","menuBeginnerCommunication","menuBeginnerAllDocuments","menuBeginnerTemplates","menuBeginnerPendingSignatures","menuBeginnerAiScanner","menuBeginnerModelling","menuBeginnerExitEstimator","menuBeginnerReporting","menuBeginnerEquityBenchmarks","menuBeginnerAuditLog","menuBeginnerRaise","mapPin","filterFlag","idBadge","phone","users","RichTextEditorIcons","tipTapAlignCenterIcon","tipTapAlignJustifyIcon","tipTapAlignLeftIcon","tipTapAlignRightIcon","tipTapArrowLeftIcon","tipTapBanIcon","tipTapBlockQuoteIcon","tipTapBoldIcon","tipTapChevronDownIcon","tipTapCloseIcon","tipTapCodeBlockIcon","tipTapCode2Icon","tipTapCornerDownLeftIcon","tipTapExternalLinkIcon","tipTapHeadingFiveIcon","tipTapHeadingFourIcon","tipTapHeadingIcon","tipTapHeadingOneIcon","tipTapHeadingSixIcon","tipTapHeadingThreeIcon","tipTapHeadingTwoIcon","tipTapImagePlusIcon","tipTapItalicIcon","tipTapLinkIcon","tipTapListIcon","tipTapListOrderedIcon","tipTapListTodoIcon","tipTapRedo2Icon","tipTapStrikeIcon","tipTapSubscriptIcon","tipTapSuperscriptIcon","tipTapTableIcon","tipTapTrashIcon","tipTapUndo2Icon","tipTapUnderlineIcon","tipTapEmojiIcon","tipTapVideoIcon","Illustrations","signaturePadPlaceholder","documentPDF","documentScan","documentList","documentEmpty","messageEmpty","illustrationActionsEmpty","documentUpload","documentValuation","cardBackgroundEllipse","Logos","cakeLogo","OnboardingStatusType","NONE","RETURNING_USER","NEW_USER","useUserProfile","name","email","isSupportAdmin","hasCompanies","onboardingStatus","needsToAcceptNewTerms","needsToDismissNewUserScreen","useAppConfig","paginationSize","itemsPerLoad","useUserPreferences","persist","set","userCurrency","setUserCurrency","new_currency","employeeGoalFeedbackUsage","setEmployeeGoalFeedbackUsage","new_value","skinTone","setSkinTone","tone","useUnauthenticatedStore","hideHeader","setHideHeader","hide","appContext","el","getElementById","hex","textContent","trim","json","match","b","parseInt","byte","i","String","fromCharCode","charCodeAt","join","decodeXorFromHex","parse","e","loadAppContext","initializeCakeStores","authenticatedUser","AUTHENTICATED_USER","setState","httpLink","HttpLink","headers","csrf_token","uri","BASE_DOMAIN_URL","fetch","async","response","reload","apolloCache","InMemoryCache","typePolicies","Query","fields","organisation","merge","EsopOffer","keyFields","EssOffer","OrganisationRaiseOffer","NotesRoundOffer","ShareTransferOfferType","BoardApprovalType","BillingShareholderType","SharetypeHoldingType","StakeholderAssetsPreviewType","StakeholderVestablePlanHoldingsType","networkStoreInitiaState","csrfToken","apolloClient","ApolloClient","link","cache","axios","defaults","xsrfCookieName","xsrfHeaderName","withXSRFToken","ORG_DATA","initialize","userId","useServerSentEventsStore","sse","SKIP_SSE_ORG_CHECK","Icon","source","fillcolor","strokecolor","width","height","rotate","margin","marginTop","marginBottom","marginLeft","marginRight","forwardedRef","iconSrc","setIconSrc","useState","internalRef","useRef","useEffect","current","fetchData","contentRef","getMargin","fetchSrc","innerHTML","react","iconCache","iconPromiseCache","iconPromise","status","startsWith","iconContent","loadIcon","imgContent","fileName","split","pop","replace","classList","_retryCount","_minRetryTime","_jitterTime","_privateEvents","_listeners","_skipSseOrgCheck","_onEvent","_onStreamError","_onOpen","_destroy","_ReconnectingEventSourceWithTimeout","ReconnectingEventSource","__privateAdd","_onerror","this","__privateSet","__privateGet","MAX_RETRIES","_eventSource","timeout","Math","round","random","_timer","setTimeout","_start","_onopen","super","__publicField","ReconnectingEventSourceWithTimeout","ServerSentEvents","listener","push","removeListener","l","success","organisationId","DEFAULT_SELECTED_COMPANY_ID","organisation_id","forEach","err","query","errors","cakeUpdateAvailable","platformVersion","PLATFORM_VERSION","riot","update","skipSseOrgCheck","onopen","onmessage","setEvent","eventName","payload","state","eventPayloads","_handleEventInternal","addListener","Object","keys","emitter","mitt","useServerSentEvents","effect","eventKeys","isMounted","selectedPayloads","useShallow","previousPayloadsRef","length","setupObserver","riotThis","callback","on","off","orgChangeDebounceCb","clearTimeout","emit","triggerInternalEvent","padding","paddingTop","paddingBottom","paddingLeft","paddingRight","background","getSize","getPadding","style","Array","isArray","s","Box","orientation","gap","wrap","position","inline","block","getAlign","al","cookieStorage","getItem","Cookies","setItem","value","expires","removeItem","remove","REDIRECT_KEY","badOrgDetection","orgId","path","count","raw","localStorage","parsed","Number","isNaN","safeCount","orgResetting","showChecklist","hideAuthorizedSharesPrompt","canAdminShareRegistry","canEditShareRegistry","isLLC","resetOrganisation","redirectPath","setShowChecklist","show","setHideAuthorizedSharesPrompt","hasUserCompanyRoles","roles","desiredRoles","userRoles","some","role","includes","storage","createJSONStorage","partialize","loaderSizes","small","regular","big","Loader","fill","_","index","buttonVariants","primary","secondary","tertiary","outlined","admin","buttonSizes","tiny","iconSizes","iconPosition","left","right","iconPlacement","iconRotate","iconSize","dataTest","disabled","Line","line","Shape","shape","Card","forwardRef","borderRadius","borderColor","borderStyle","card"],"ignoreList":[],"sourceRoot":""}