text:
88, 0x62, 0x0d, 0xc3, 0x24, 0xc3, 0x43, 0x37, 0x61, 0xaa, 0x93, 0xf4, 0x9e, 0x52, 0xd6,
	0x98, 0x10, 0x14, 0x88, 0x53, 0xcc, 0x2b, 0xbd, 0x04, 0x00, 0x13, 0x85, 0xc1, 0x71, 0xf9, 0x04,
	0x7a, 0x5f, 0x34, 0x26, 0x0b, 0xb8, 0x43, 0x01, 0xc0, 0x44, 0x61, 0xe0, 0x7f, 0xab, 0xc1, 0xa2,
	0x8a, 0x94, 0xd4, 0x09, 0x6f, 0x97, 0xe5, 0xd8, 0x22, 0x67, 0x02, 0x92, 0xc9, 0xcf, 0x3d, 0x37,
	0x97, 0x62, 0x4f, 0xe0, 0x3c, 0xaf, 0x1c, 0x59, 0xdc, 0xec, 0xd1, 0xc1, 0xd0, 0x77, 0x98, 0x8c,
	0x84, 0xd9, 0x5b, 0x2b, 0x46, 0xe6, 0xa4, 0xa1, 0xd5, 0xb9, 0xc4, 0x79, 0xae, 0x49, 0x9e, 0xbc,
	0xdc, 0xac, 0x0f, 0x33, 0x20, 0x26, 0x23, 0x38, 0xa2, 0x3b, 0x30, 0x7f, 0x2f, 0x89, 0x59, 0x38,
	0xe8, 0xf6, 0xc2, 0x20, 0x8b, 0x1d, 0x33, 0xf9, 0xbc, 0x5e, 0x18, 0xac, 0x27, 0x7c, 0xaa, 0x6c,
	0x54, 0xf4, 0x2e, 0x4c, 0xf2, 0xf8, 0x18, 0x11, 0x35, 0x66, 0xbc, 0xfa, 0x1c, 0x0d, 0x13, 0x89,
	0x8e, 0xb6, 0x60, 0x49, 0x99, 0xdb, 0x71, 0x82, 0x80, 0x46, 0x5c, 0xac, 0x74, 0x6e, 0x93, 0xd3,
	0xac, 0x9a, 0x09, 0x75, 0xbc, 0xbe, 0x2f, 0x70, 0x30, 0x29, 0xd0, 0xa0, 0x7d, 0x58, 0xcc, 0x85,
	0x5c, 0x63, 0x4a, 0x38, 0xa8, 0x99, 0x6a, 0x52, 0x08, 0x4a, 0xcb, 0x4d, 0xb1, 0x84, 0xad, 0xc7,
	0x0a, 0x88, 0x49, 0x9e, 0x21, 0xfe, 0xdf, 0x09, 0x98, 0xd6, 0x65, 0x1c, 0xdd, 0x2e, 0x5b, 0xc6,
	0x8a, 0x93, 0x69, 0x21, 0xa1, 0x4f, 0x61, 0x36, 0x2b, 0x1b, 0xb1, 0x9a, 0xc2, 0x4b, 0x99, 0x86,
	0xc5, 0x12, 0xd6, 0x59, 0xe3, 0x1c, 0x91, 0x8a, 0xb1, 0x8c, 0x96, 0x2f, 0x00, 0xd9, 0x17, 0x7a,
	0x0b, 0xa6, 0xb7, 0x12, 0xdf, 0x17, 0x61, 0x55, 0x9c, 0xb5, 0x03, 0x05, 0xc2, 0x24, 0xc5, 0xe2,
	0xc9, 0xb2, 0xed, 0x1d, 0xd1, 0x40, 0x90, 0x4c, 0x14, 0x92, 0xe5, 0x50, 0xc3, 0x30, 0xc9, 0xf0,
	0x78, 0x3d, 0xdd, 0x72, 0x06, 0x9e, 0x2f, 0xe3, 0x77, 0xb2, 0x50, 0x5a, 0x0e, 0x52, 0x20, 0x26,
	0x06, 0xa6, 0x48, 0xe7, 0x23, 0x87, 0x39, 0x62, 0x7a, 0xa7, 0x8a, 0xe9, 0xac, 0x61, 0x3c, 0x9d,
	0xf5, 0x6f, 0xb4, 0x0e, 0xd3, 0xbf, 0x1f, 0xee, 0xef, 0x79, 0xcc, 0xa7, 0x8d, 0x7a, 0xb1, 0xec,
	0xf1, 0x71, 0x4c, 0x52, 0x14, 0xd4, 0x81, 0x85, 0x07, 0x4e, 0xdc, 0xa7, 0xee, 0x8e, 0x13, 0xc7,
	0xcf, 0xc2, 0xc8, 0x6d, 0x4c, 0x17, 0xe2, 0xa8, 0x6f, 0x21, 0x60, 0x92, 0xa3, 0x40, 0x9f, 0xca,
	0x76, 0xc5, 0x48, 0xa5, 0xc6, 0xcc, 0x98, 0x34, 0xb3, 0xe6, 0xc6, 0xcc, 0xb0, 0x3c, 0x17, 0x3e,
	0x3f, 0xed, 0xa1, 0xb7, 0x17, 0x3e, 0xa5, 0x41, 0x03, 0x0a, 0xf3, 0xe3, 0x28, 0x10, 0x26, 0x29,
	0x16, 0x7e, 0x13, 0x56, 0xf4, 0xef, 0x87, 0xe1, 0xa1, 0x17, 0xe8, 0xd6, 0x65, 0x05, 0x26, 0x25,
	0x1b, 0xd9, 0xb4, 0xc8, 0x0f, 0xfc, 0x63, 0x58, 0xdd, 0xf1, 0x1d, 0x2f, 0xe0, 0x72, 0x2d, 0xf4,
	0xa6, 0x0c, 0x59, 0xa3, 0xcd, 0x49, 0xbf, 0x39, 0x2c, 0xf5, 0x95, 0x6c, 0x70, 0xd2, 0x6f, 0xfc,
	0x1c, 0xe6, 0x15, 0x9f, 0xac, 0x51, 0xdc, 0x4d, 0x44, 0xa9, 0x2d, 0x69, 0x14, 0x15, 0x04, 0x13,
	0x8d, 0x93, 0xa9, 0x59, 0x35, 0xd4, 0x44, 0xaf, 0xc1, 0x04, 0x97, 0x2e, 0x42, 0xb4, 0xb4, 0x39,
	0x12, 0x60, 0xbc, 0x04, 0x0b, 0x7f, 0x48, 0x23, 0x1e, 0xd9, 0xba, 0x8f, 0x6c, 0xc1, 0x39, 0x35,
	0x22, 0x5b, 0x49, 0xa5, 0x54, 0x03, 0xea, 0x6a, 0x58, 0x19, 0xa7, 0x3f, 0xf1, 0x1d, 0x38, 0x9f,
	0xab, 0xbe, 0xa7, 0x6f, 0x1e, 0x7f, 0x59, 0x81, 0x85, 0xb6, 0xeb, 0x1a, 0x7d, 0x2c, 0xba, 0x04,
	0x33, 0xfc, 0x53, 0x24, 0xb3, 0x22, 0xc9, 0x06, 0xf2, 0x2c, 0xab, 0xc5, 0x76, 0xf2, 0x87, 0x76,
	0xe2, 0x4b, 0xfb, 0x4f, 0x68, 0x29, 0xac, 0x0c, 0xc7, 0xd7, 0xe0, 0x4a, 0xfb, 0xc8, 0xf1, 0x7c,
	0x67, 0xdf, 0xa7, 0xe5, 0x96, 0x61, 0x0f, 0x1a, 0xa3, 0x50, 0xd0, 0x8f, 0xcc, 0x8e, 0x46, 0xf6,
	0xa6, 0x8d, 0xbc, 0xf8, 0xb4, 0x2e, 0xca, 0xdc, 0x94, 0x53, 0x7b, 0xaf, 0xb4, 0x97, 0xf1, 0x60,
	0xbe, 0x7d, 0x48, 0x03, 0x96, 0x7a, 0xb5, 0x01, 0x75, 0xc5, 0x45, 0xcf, 0x84, 0xfa, 0x44, 0x1f,
	0xc3, 0xdc, 0xe3, 0xa1, 0xeb, 0x30, 0xea, 0xee, 0x7a, 0x41, 0x4f, 0xaf, 0x5b, 0xcd, 0x0d, 0xb9,
	0x7d, 0xda, 0xd0, 0xfb, 0xab, 0x8d, 0x3d, 0xbd, 0xbf, 0x22, 0x16, 0x3e, 0x7e, 0x1f, 0x16, 0xb4,
	0x28, 0x35, 0xeb, 0xdf, 0x83, 0x29, 0x39, 0xa2, 0x0c, 0x59, 0x48, 0x0d, 0x11, 0xc3, 0x44, 0x41,
	0xf1, 0x2a, 0x9c, 0x23, 0xf4, 0x20, 0xa2, 0x71, 0x5f, 0x44, 0x9f, 0x76, 0xd3, 0x32, 0x2c, 0xea,
	0xc6, 0x51, 0x0f, 0xdd, 0x87, 0x15, 0x3d, 0xf4, 0xd0, 0x8b, 0x59, 0x2a, 0xe9, 0x4d, 0xa3, 0x53,
	0x95, 0xb2, 0x96, 0xf2, 0x9d, 0xaa, 0xd1, 0x85, 0x7e, 0x08, 0x6b, 0xbb, 0xbd, 0x88, 0xd2, 0x20,
	0xee, 0x87, 0x4c, 0xda, 0x90, 0x05, 0x5d, 0xb5, 0x2b, 0x77, 0x58, 0x26, 0x0b, 0xa1, 0x67, 0xd7,
	0x25, 0xd5, 0xae, 0x8b, 0x7f, 0x51, 0x81, 0x85, 0x2d, 0xcf, 0xa7, 0x8f, 0x87, 0x7e, 0xe8, 0xb8,
	0x62, 0x89, 0x79, 0xcd, 0x20, 0x5a, 0xb5, 0x16, 0xd4, 0xae, 0x4b, 0x03, 0xe6, 0xb1, 0x63, 0x4e,
	0x89, 0x10, 0x4c, 0xec, 0x7a, 0x5f, 0x4a, 0xc7, 0xd6, 0x88, 0xf8, 0x2d, 0x23, 0x32, 0x60, 0x34,
	0x60, 0x7b, 0xc7, 0x43, 0xb5, 0x24, 0x10, 0x73, 0x88, 0x27, 0x3f, 0x17, 0x97, 0x95, 0x7f, 0x92,
	0x7e, 0xe3, 0x7f, 0xad, 0xc0, 0x12, 0x17, 0xc3, 0x7d, 0xa1, 0x45, 0xf1, 0x02, 0x60, 0xcd, 0xb0,
	0xd5, 0xc1, 0xa9, 0x05, 0x1a, 0x67, 0xd3, 0xbe, 0x0e, 0x75, 0xe5, 0x18, 0xd5, 0xbf, 0x99, 0xe8,
	0xaa, 0x87, 0xc7, 0x44, 0xe3, 0xa0, 0xb7, 0x00, 0x36, 0x85, 0x9c, 0x4c, 0x5f, 0xab, 0x1f, 0x66,
	0xc7, 0x43, 0xbe, 0xa6, 0x64, 0x38, 0xe8, 0x26, 0x4c, 0xcb, 0xaf, 0xae, 0xab, 0xd6, 0xaf, 0x05,
	0x8e, 0x3f, 0xa3, 0x1a, 0x15, 0x17, 0x93, 0x14, 0x8e, 0x5b, 0x30, 0xad, 0xed, 0x41, 0xaf, 0xc2,
	0xa4, 0x68, 0x41, 0xd4, 0x84, 0xda, 0x9d, 0x0a, 0x91, 0x30, 0xfc, 0x08, 0xea, 0xfc, 0x93, 0x2f,
	0x43, 0x4b, 0x50, 0x4b, 0xbb, 0x56, 0xc2, 0x7f, 0xa2, 0x77, 0xa0, 0xbe, 0xf9, 0xc5, 0xd0, 0x8b,
	0x68, 0x2c, 0xd6, 0xa5, 0xf1, 0xc1, 0xac, 0x51, 0xf1, 0xaf, 0xab, 0x30, 0x67, 0xce, 0x1d, 0x7a,
	0x2f, 0xef, 0xd0, 0x57, 0xb8, 0xfe, 0x0d, 0xcb, 0xa1, 0x6f, 0x86, 0x03, 0x8f, 0xd1, 0xc1, 0x90,
	0x99, 0xae, 0x7d, 0x2f, 0xef, 0x5a, 0x93, 0x50, 0xb9, 0xd6, 0x22, 0xd4, 0x4e, 0xbe, 0x53, 0xe2,
	0x64, 0x73, 0x79, 0xe4, 0x4e, 0x36, 0x09, 0x4d, 0x77, 0xbf, 0x53, 0x70, 0x77, 0x83, 0x53, 0x9e,
	0xd3, 0xee, 0x36, 0xe9, 0x52, 0x4c, 0xb4, 0x01, 0x13, 0x46, 0xab, 0x60, 0xca, 0xe2, 0xdb, 0x49,
	0x93, 0x46, 0xe0, 0xe1, 0xff, 0xab, 0xc2, 0x04, 0x77, 0x12, 0x7a, 0xf7, 0xc4, 0xd8, 0x2f, 0xf6,
	0x5a, 0x3c, 0x19, 0xae, 0xc3, 0x84, 0x30, 0xae, 0x3a, 0x22, 0x82, 0x04, 0x94, 0x6f, 0xa7, 0x7e,
	0x1c, 0xb9, 0x6a, 0x21, 0x9a, 0xb4, 0xfa, 0x8a, 0x90, 0x8f, 0x63, 0x22, 0xe1, 0xe8, 0x9a, 0x9c,
	0xfc, 0x89, 0x42, 0x73, 0x27, 0x7a, 0xe0, 0x9a, 0x6c, 0x53, 0xea, 0xf7, 0x22, 0xea, 0xb0, 0x30,
	0x52, 0x56, 0x5a, 0x79, 0x21, 0x21, 0x7c, 0xf2, 0xe4, 0x2f, 0x74, 0x5f, 0xe6, 0x1d, 0x4f, 0x70,
	0xd5, 0xa1, 0x22, 0xbb, 0xff, 0xe3, 0x50, 0xbb, 0x7b, 0xf3, 0x7c, 0xea, 0x05, 0x07, 0x21, 0x26,
	0x29, 0x25, 0xea, 0x42, 0x5d, 0x15, 0xc9, 0x93, 0x43, 0xd0, 0x52, 0x28, 0x91, 0x54, 0x98, 0x68,
	0x7a, 0xfc, 0xcf, 0x15, 0x98, 0x49, 0x05, 0x73, 0xff, 0xed, 0x38, 0xac, 0x5f, 0xb2, 0x23, 0x1d,
	0x3a, 0xac, 0x8f, 0x89, 0x80, 0x8a, 0x76, 0x53, 0x17, 0x8f, 0x6a, 0xb1, 0xdd, 0xf4, 0x7c, 0x1a,
	0xa8, 0x76, 0x53, 0x61, 0xa1, 0x0f, 0x4a, 0x0a, 0x92, 0xd5, 0x3f, 0xf5, 0x24, 0x54, 0xce, 0x92,
	0x55, 0xa9, 0xae, 0xab, 0xfa, 0xc6, 0x27, 0xa1, 0x66, 0xa9, 0x14, 0x7b, 0x5f, 0xf2, 0x29, 0xe5,
	0x50, 0x3c, 0x4c, 0xab, 0xfa, 0xcb, 0x56, 0x2c, 0x1d, 0xab, 0xd5, 0x53, 0xc6, 0xea, 0x7f, 0xd5,
	0xd2, 0x3c, 0x44, 0x1f, 0x18, 0xe1, 0xda, 0xc8, 0x2f, 0x11, 0xe3, 0x23, 0x36, 0xdd, 0x39, 0x55,
	0xcf, 0xb6, 0x73, 0xda, 0x84, 0xc5, 0x76, 0xc2, 0xc2, 0x81, 0x38, 0x76, 0xdc, 0x0b, 0x43, 0x5f,
	0x1e, 0xa6, 0xcc, 0x74, 0x2e, 0x72, 0x92, 0xf3, 0xaa, 0xb3, 0xb4, 0x31, 0x30, 0xc9, 0xd3, 0x88,
	0x84, 0x71, 0x0e, 0xe5, 0xbe, 0x2d, 0x97, 0x30, 0x0e, 0xdf, 0x05, 0x09, 0x28, 0xfa, 0x0c, 0xa0,
	0xcd, 0x58, 0xe4, 0xed, 0x27, 0x8c, 0xc6, 0x8d, 0x49, 0xa1, 0xe9, 0xd5, 0xbc, 0x9d, 0x1b, 0x19,
	0xca, 0x66, 0xc0, 0xa2, 0x63, 0x6b, 0x6b, 0xe0, 0xa4, 0x30, 0x4c, 0x0c, 0x5e, 0xe8, 0x31, 0xcc,
	0x3e, 0x74, 0x62, 0xa6, 0xa3, 0x79, 0xea, 0xc4, 0x68, 0x36, 0x83, 0xc6, 0xcf, 0x28, 0x31, 0x31,
	0xf9, 0x34, 0x3f, 0x82, 0xc5, 0x9c, 0x36, 0xbc, 0x90, 0x3f, 0xa5, 0xba, 0x3d, 0xe1, 0x3f, 0x79,
	0x93, 0x7a, 0xe4, 0xf8, 0x89, 0xee, 0xd8, 0xe4, 0xc7, 0x9d, 0xea, 0xfb, 0x15, 0xfc, 0x55, 0x05,
	0x96, 0x79, 0x5c, 0x84, 0x81, 0x58, 0xa1, 0x55, 0x40, 0x6d, 0x67, 0x85, 0xf7, 0xa4, 0xa9, 0x1e,
	0xbf, 0xda, 0x5d, 0xb7, 0x42, 0xad, 0x78, 0xca, 0x26, 0x03, 0xec, 0xcf, 0x2a, 0xb2, 0x69, 0x13,
	0x4a, 0xa0, 0x0f, 0x8d, 0x10, 0x6b, 0x5a, 0xad, 0x9b, 0xa5, 0x64, 0x79, 0x90, 0x7d, 0x00, 0xb3,
	0xf7, 0x69, 0xdc, 0x8b, 0xbc, 0x21, 0x9f, 0x79, 0x25, 0xd7, 0xf4, 0xa4, 0x9b, 0x41, 0x31, 0x31,
	0x71, 0xf1, 0x7f, 0x56, 0xa0, 0xbe, 0x45, 0x1d, 0x96, 0x44, 0x14, 0xbd, 0x91, 0xea, 0x30, 0xd7,
	0xb9, 0xc0, 0xa9, 0x57, 0x52, 0x39, 0x66, 0x7e, 0xa8, 0x42, 0x7c, 0xb2, 0x89, 0xe8, 0x9e, 0xec,
	0x9c, 0x95, 0x05, 0xa2, 0x2c, 0xcc, 0x75, 0xae, 0x71, 0xe4, 0x4b, 0x59, 0x9a, 0x2a, 0xa8, 0x29,
	0xc1, 0xa4, 0x42, 0xef, 0xc1, 0x4c, 0xea, 0x7e, 0x55, 0xaa, 0xc7, 0x28, 0x97, 0xe1, 0xe2, 0x6f,
	0x26, 0x61, 0x7a, 0x8f, 0xc6, 0xac, 0xe7, 0xc4, 0xbf, 0x03, 0xdb, 0x3e, 0x86, 0xf9, 0x2c, 0xd9,
	0xb2, 0x23, 0x29, 0x73, 0xd9, 0xcc, 0xd2, 0xb3, 0xeb, 0x62, 0x62, 0xa3, 0xf3, 0x0d, 0xad, 0x9d,
	0xac, 0xca, 0x36, 0xb3, 0x32, 0xd9, 0xf9, 0x8d, 0x49, 0x8e, 0x22, 0xef, 0xdf, 0xc9, 0x97, 0xf2,
	0xef, 0x3a, 0xd4, 0xef, 0x53, 0x9f, 0xea, 0xf4, 0x9c, 0xb6, 0x82, 0xdb, 0x95, 0x10, 0x4c, 0x34,
	0x0e, 0x7a, 0x00, 0x4b, 0xdd, 0xc1, 0x30, 0x8c, 0x98, 0x13, 0xf4, 0x28, 0x71, 0xf8, 0x96, 0x42,
	0x2c, 0x52, 0x93, 0xd6, 0x79, 0x8b, 0x97, 0x43, 0xc1, 0xa4, 0x40, 0x85, 0xee, 0xc2, 0x7c, 0x37,
	0x70, 0x7a, 0xcc, 0x3b, 0xa2, 0x9f, 0x84, 0xbc, 0xf0, 0x4c, 0x8b, 0x22, 0x65, 0xce, 0x8e, 0x67,
	0xc2, 0x31, 0xb1, 0xf1, 0xd1, 0x47, 0x66, 0x64, 0xcc, 0x08, 0xef, 0x5d, 0xe1, 0xc4, 0x4d, 0x2b,
	0x31, 0xbb, 0x23, 0xe2, 0x83, 0x97, 0xd8, 0x5d, 0xe6, 0xec, 0x7b, 0x3e, 0x6f, 0xb5, 0xa5, 0x21,
	0x20, 0x0c, 0x31, 0x4b, 0x6c, 0x6c, 0x63, 0x88, 0x73, 0x23, 0x6b, 0x84, 0x77, 0x1b, 0xbb, 0x8c,
	0x0e, 0xe3, 0xc6, 0x6c, 0xe1, 0x74, 0x3e, 0xe6, 0xe3, 0x98, 0x48, 0x78, 0x5a, 0x8b, 0xe7, 0xc6,
	0xd5, 0x62, 0xfc, 0x13, 0x98, 0xe1, 0x41, 0x3b, 0xf4, 0x9d, 0x20, 0xfe, 0xce, 0xa3, 0x16, 0xff,
	0x4b, 0x4d, 0xe6, 0x44, 0x94, 0xfc, 0x0e, 0xb8, 0xdb, 0xa9, 0x5a, 0x3b, 0x7d, 0xaa, 0x72, 0x1f,
	0x76, 0x12, 0xcf, 0xd7, 0xf9, 0x6d, 0xfa, 0x70, 0x9f, 0x8f, 0x63, 0x22, 0xe1, 0x88, 0x00, 0x90,
	0x24, 0xd8, 0x65, 0x4e, 0xc4, 0xe3, 0x75, 0xf2, 0xc4, 0xe5, 0xc4, 0x5c, 0xa3, 0xa2, 0x94, 0x10,
	0x13, 0x83, 0x0b, 0x5f, 0xa3, 0x48, 0x12, 0x6c, 0x79, 0x81, 0x17, 0xf7, 0xcf, 0xbc, 0x46, 0x45,
	0x19, 0x25, 0x26, 0x26, 0x1f, 0x19, 0x17, 0x0e, 0x2b, 0x3b, 0xdd, 0x8a, 0xf9, 0xb8, 0x88, 0x0b,
	0x87, 0xf1, 0xe6, 0x09, 0xf4, 0x8c, 0x77, 0xf5, 0xb1, 0xd6, 0x18, 0xb7, 0x19, 0xc8, 0xf8, 0x67,
	0x50, 0x57, 0xbb, 0xcc, 0xb3, 0xb6, 0x43, 0xa7, 0x0b, 0x97, 0x5f, 0x55, 0x60, 0x49, 0x08, 0x50,
	0x97, 0x7f, 0x5c, 0x74, 0x4a, 0x5a, 0x19, 0x1b, 0x0b, 0xaa, 0xb7, 0xae, 0x8e, 0xe9, 0xad, 0x7f,
	0x00, 0x73, 0x6d, 0xa3, 0x44, 0x9e, 0x58, 0x41, 0x2d, 0x6c, 0xfc, 0xb7, 0x15, 0x58, 0xd3, 0xbb,
	0x74, 0xea, 0x53, 0x27, 0xa6, 0x22, 0x44, 0x44, 0x03, 0xbd, 0x6e, 0x2f, 0xe5, 0x27, 0x6d, 0x4f,
	0xd7, 0xa1, 0xae, 0x58, 0x94, 0xec, 0x66, 0x23, 0x09, 0xc1, 0x44, 0xe3, 0x64, 0xd1, 0x5a, 0x1b,
	0x1f, 0xad, 0xf8, 0x9b, 0x0a, 0x2c, 0x0b, 0xf7, 0x3d, 0x4a, 0x68, 0x42, 0xdd, 0x76, 0x8f, 0xab,
	0x8e, 0xde, 0x1e, 0x77, 0x5a, 0x50, 0xbe, 0xc0, 0xdf, 0x84, 0x29, 0x49, 0xac, 0xf4, 0x33, 0xaf,
	0x26, 0x9c, 0x9e, 0x5c, 0xd6, 0x15, 0x06, 0xba, 0x0b, 0x8b, 0xf2, 0xd7, 0x8e, 0x13, 0x39, 0x03,
	0xca, 0xd4, 0x3e, 0xc8, 0x3e, 0x93, 0x1d, 0x6a, 0x18, 0xef, 0x19, 0x6d, 0x6c, 0x9c, 0xa8, 0x23,
	0x19, 0x99, 0x22, 0x2c, 0x89, 0x5f, 0x46, 0xe3, 0xb7, 0x60, 0x26, 0xa5, 0x2f, 0x51, 0x3a, 0x16,
	0x00, 0x4c, 0x32, 0x24, 0xfc, 0x17, 0xda, 0x59, 0xf2, 0x5b, 0xb6, 0x7a, 0x2f, 0x23, 0xfa, 0x87,
	0x30, 0x65, 0xc8, 0x35, 0x4f, 0x77, 0x0d, 0xf6, 0xa5, 0xda, 0x28, 0x3a, 0xfc, 0xff, 0xd3, 0x30,
	0x6b, 0xe0, 0xa2, 0xdb, 0xa6, 0x31, 0x45, 0x67, 0x46, 0xa9, 0x0d, 0x86, 0x3d, 0x7c, 0xce, 0xb6,
	0xa3, 0x30, 0x19, 0xea, 0xe6, 0xdb, 0x14, 0x78, 0x28, 0x00, 0x98, 0x28, 0x0c, 0xf4, 0x08, 0x66,
	0x8d, 0x0c, 0x53, 0x75, 0xed, 0x82, 0xad, 0xb7, 0x81, 0x60, 0xed, 0xc7, 0x98, 0x6a, 0x71, 0xf8,
	0xb2, 0x6e, 0x64, 0xe9, 0x5b, 0xe2, 0x70, 0xeb, 0xc8, 0x73, 0xc5, 0x39, 0x46, 0x2d, 0xb7, 0x89,
	0x1b, 0x2a, 0x90, 0xbc, 0x66, 0x15, 0x3f, 0x79, 0x47, 0xd2, 0x89, 0xc2, 0xa7, 0x34, 0x48, 0xe9,
	0xe4, 0x82, 0x6c, 0x76, 0x24, 0xfb, 0x16, 0x02, 0x26, 0x39, 0x0a, 0x44, 0x8c, 0x23, 0xb5, 0x99,
	0xf2, 0x7d, 0x44, 0x3e, 0x59, 0x4f, 0xba, 0xfe, 0x35, 0x82, 0x1f, 0x4e, 0x0c, 0xfe, 0xcd, 0x62,
	0xf0, 0xcf, 0x0a, 0x22, 0x6b, 0xdb, 0x94, 0x0b, 0xf8, 0x42, 0x0a, 0x70, 0xe7, 0x3d, 0x70, 0x22,
	0xf7, 0x99, 0x13, 0xd1, 0xc6, 0x5c, 0x61, 0x07, 0xdc, 0x57, 0x20, 0x4c, 0x52, 0x2c, 0x74, 0x19,
	0xaa, 0xdd, 0x9d, 0xc6, 0x7c, 0xf1, 0xa4, 0x6a, 0xc8, 0x83, 0x72, 0x47, 0xdc, 0x55, 0xf7, 0xc3,
	0xc4, 0x77, 0x37, 0xbf, 0xf0, 0x58, 0x63, 0x41, 0x34, 0x5a, 0xd6, 0x5d, 0x75, 0x0a, 0xc4, 0xc4,
	0xc0, 0x44, 0x7b, 0x30, 0xad, 0x0e, 0xbd, 0xe3, 0xc6, 0xa2, 0x70, 0x28, 0x2e, 0x0b, 0xe7, 0x0d,
	0x8d, 0x24, 0xb7, 0x66, 0xa6, 0xb6, 0x47, 0x0a, 0x82, 0x49, 0xca, 0x09, 0xfd, 0xc4, 0xda, 0xf0,
	0x2d, 0x09, 0xbe, 0xd7, 0x4b, 0xf9, 0xbe, 0xcc, 0xa6, 0xef, 0x4f, 0x01, 0x11, 0xfa, 0x79, 0xe2,
	0x45, 0xd4, 0x35, 0xa4, 0x20, 0x21, 0xe5, 0xcd, 0x52, 0x29, 0x45, 0x74, 0x29, 0xed, 0x32, 0x97,
	0x76, 0x41, 0xd7, 0xe1, 0x3c, 0x0e, 0x26, 0x25, 0x72, 0x9a, 0x1f, 0xc2, 0xbc, 0xe5, 0x8c, 0xb3,
	0xec, 0x0c, 0xbf, 0xe5, 0xc6, 0xb2, 0xb9, 0x09, 0x6b, 0x23, 0x4c, 0x39, 0xd3, 0xfe, 0xf4, 0x1f,
	0x27, 0x60, 0x52, 0xb8, 0xe7, 0x65, 0xca, 0x5f, 0x07, 0x16, 0xc4, 0x95, 0x5e, 0xbe, 0xfc, 0x9a,
	0x69, 0x7c, 0x68, 0x21, 0x60, 0x92, 0xa3, 0xe0, 0x1b, 0x4a, 0x31, 0xa2, 0xf2, 0xae, 0x78, 0x9e,
	0x73, 0x98, 0x41, 0x31, 0x31, 0x71, 0xd1, 0x1e, 0xac, 0x18, 0x9f, 0x59, 0x1a, 0xca, 0xce, 0xee,
	0x2a, 0xe7, 0x71, 0xb1, 0xc0, 0xc3, 0xc8, 0xc5, 0x52, 0x6a, 0x5e, 0x20, 0xf9, 0xfe, 0xff, 0x5e,
	0x9f, 0xf6, 0x9e, 0x7a, 0xc1, 0x29, 0x1a, 0x3f, 0xab, 0xfb, 0xe1, 0x54, 0xdd, 0x40, 0x9d, 0x21,
	0x28, 0x1e, 0xc8, 0x87, 0x15, 0xfe, 0x99, 0x3f, 0xd3, 0x3f, 0x45, 0xff, 0x67, 0x5d, 0x2c, 0xe7,
	0xc8, 0x31, 0x29, 0xe5, 0xca, 0x17, 0x25, 0xb9, 0xca, 0xa8, 0x13, 0xbd, 0x33, 0x2c, 0x4a, 0xf2,
	0x07, 0x7a, 0x15, 0x26, 0xbb, 0x03, 0xe7, 0x90, 0xaa, 0x0e, 0x71, 0x9e, 0xa3, 0x4e, 0x4b, 0xd4,
	0x75, 0x4c, 0x24, 0xec, 0xd6, 0x7f, 0xd7, 0x60, 0xa2, 0x9d, 0xb0, 0x3e, 0xfa, 0xab, 0x0a, 0xcc,
	0x99, 0x4f, 0xc2, 0x50, 0x76, 0x0f, 0x5d, 0xf2, 0x48, 0xad, 0xf9, 0xca, 0x08, 0xa8, 0xbc, 0x29,
	0xc1, 0xdb, 0x5f, 0xfd, 0xfb, 0x6f, 0xfe, 0xb2, 0xda, 0x46, 0x77, 0xe5, 0x7b, 0xb8, 0x84, 0xf5,
	0x5b, 0x9e, 0x81, 0xd7, 0x7a, 0x6e, 0xdc, 0x86, 0xbd, 0x68, 0x3d, 0x37, 0x1e, 0x2f, 0xf1, 0xaf,
	0xf4, 0x9e, 0xeb, 0x05, 0x8a, 0x61, 0x41, 0x5c, 0x3c, 0x7e, 0xea, 0x31, 0x79, 0x6d, 0x83, 0x32,
	0xc9, 0x65, 0x17, 0xa2, 0xcd, 0xf3, 0xd9, 0x81, 0x99, 0x79, 0x61, 0x89, 0x6f, 0x0a, 0x8d, 0xae,
	0x23, 0x9c, 0x69, 0xe4, 0x73, 0x84, 0xf5, 0x67, 0x1e, 0xeb, 0xaf, 0x33, 0xce, 0xa7, 0xf5, 0x5c,
	0xb0, 0x7b, 0x81, 0x9e, 0xc0, 0x4a, 0x2a, 0xf4, 0x5e, 0x44, 0xc5, 0x51, 0x8a, 0xe3, 0xc7, 0xc8,
	0x78, 0x97, 0x54, 0x76, 0xbb, 0x3a, 0x52, 0x76, 0x53, 0xc8, 0x5e, 0xc1, 0x8b, 0x39, 0xd9, 0x77,
	0x2a, 0x37, 0x11, 0x85, 0x39, 0xf3, 0x56, 0xca, 0x70, 0x7b, 0xc9, 0x65, 0xd5, 0x48, 0x09, 0x57,
	0x84, 0x84, 0x0b, 0x68, 0x2d, 0x93, 0x10, 0x49, 0x72, 0x69, 0xda, 0xad, 0x6f, 0x26, 0x61, 0x52,
	0xbc, 0x4f, 0x43, 0x7f, 0x02, 0x68, 0x9b, 0x32, 0xe3, 0x71, 0x9e, 0x68, 0x80, 0x2f, 0x66, 0x47,
	0x48, 0x85, 0x67, 0x7b, 0xcd, 0xe2, 0xcd, 0xac, 0x36, 0x09, 0x21, 0x21, 0x50, 0xbc, 0x61, 0x6b,
	0xf5, 0x24, 0x25, 0xda, 0x87, 0xd9, 0x6d, 0x9a, 0xb1, 0x6e, 0x14, 0xef, 0x75, 0x47, 0xf3, 0xfd,
	0x9e, 0xe0, 0x7b, 0x15, 0x5d, 0x36, 0xf8, 0x7a, 0xc1, 0x41, 0xd8, 0x7a, 0x6e, 0xbe, 0x9c, 0x78,
	0x81, 0xbe, 0xae, 0x08, 0x33, 0x72, 0xcf, 0x02, 0xd1, 0x75, 0x8b, 0xe3, 0x88, 0x07, 0x83, 0xcd,
	0x8b, 0x36, 0x96, 0xf5, 0x64, 0x0f, 0xff, 0x9e, 0xd0, 0xe0, 0x35, 0xf4, 0xaa, 0xa1, 0xc1, 0xfe,
	0xf1, 0xba, 0xda, 0x11, 0xd9, 0x91, 0x8b, 0x7e, 0x69, 0xab, 0x91, 0x1e, 0xe8, 0x15, 0xd4, 0x28,
	0x79, 0x76, 0x38, 0x5e, 0x8d, 0x0f, 0x84, 0x1a, 0xb7, 0xd1, 0xdb, 0xb6, 0x1a, 0xaa, 0xdf, 0x19,
	0x97, 0x40, 0xe8, 0x33, 0x00, 0x59, 0x44, 0x38, 0x5b, 0x54, 0x74, 0x72, 0x99, 0xdf, 0xaf, 0x0b,
	0x71, 0x97, 0x9b, 0x17, 0x0c, 0x71, 0xb6, 0xcb, 0x79, 0xb0, 0x06, 0xb0, 0xa4, 0x6e, 0xc2, 0xf7,
	0x42, 0xed, 0xf2, 0xb5, 0x2c, 0x1f, 0xad, 0x4b, 0xf2, 0x32, 0x29, 0x1b, 0x42, 0xca, 0x0d, 0x7c,
	0x1a, 0xdf, 0xde, 0xa9, 0xdc, 0xbc, 0xf5, 0x3f, 0xb5, 0x74, 0x93, 0x8a, 0x12, 0x19, 0xb7, 0xb9,
	0x8b, 0xec, 0x2b, 0xa3, 0x6e, 0xad, 0xb5, 0x16, 0x23, 0xaf, 0xb5, 0xb5, 0xc9, 0xe8, 0x92, 0x50,
	0x26, 0x7d, 0xa4, 0x97, 0x9b, 0xe1, 0xaf, 0x2a, 0x70, 0x71, 0x9b, 0xb2, 0x91, 0x37, 0xe9, 0x37,
	0x32, 0xf3, 0xc7, 0xdf, 0xc7, 0x37, 0xaf, 0x9d, 0x88, 0x89, 0xcf, 0x0b, 0x95, 0x96, 0xd0, 0x82,
	0xad, 0x12, 0x62, 0xb0, 0x2a, 0x67, 0x34, 0x2f, 0x7d, 0xa4, 0x75, 0x63, 0xec, 0x7e, 0x5d, 0x08,
	0xb9, 0xd6, 0x1c, 0x6b, 0x37, 0x9f, 0xed, 0x27, 0x80, 0xda, 0xae, 0xfb, 0x1d, 0x7a, 0xfc, 0x82,
	0x90, 0x7c, 0x0e, 0xe7, 0xcc, 0xe3, 0x33, 0xfd, 0x77, 0xd5, 0x6c, 0x23, 0x80, 0x7e, 0x2a, 0x0a,
	0x48, 0xfa, 0x59, 0x38, 0x56, 0x8f, 0x8b, 0xab, 0x50, 0xd9, 0x7d, 0x3d, 0x5e, 0x15, 0xf2, 0x16,
	0xd1, 0xbc, 0x90, 0xa7, 0xb7, 0x0a, 0xe8, 0x00, 0x96, 0x32, 0xf6, 0x1d, 0xf9, 0x22, 0x63, 0xe4,
	0xd1, 0x7d, 0xb3, 0x70, 0xc5, 0x9f, 0xab, 0x51, 0x9a, 0x6d, 0xea, 0xbf, 0x17, 0xad, 0xe7, 0x32,
	0x74, 0x08, 0x40, 0xdb, 0x75, 0x75, 0x4d, 0x38, 0x8b, 0x84, 0x86, 0x90, 0x80, 0xb0, 0xad, 0x38,
	0xf7, 0xd3, 0x3f, 0x4d, 0xa9, 0xfb, 0x21, 0xf4, 0x05, 0x4c, 0x6f, 0x53, 0x26, 0x7f, 0x5f, 0xb0,
	0x6e, 0x89, 0xcc, 0x7b, 0x7a, 0x23, 0x0b, 0x35, 0x08, 0x7f, 0x2c, 0xb8, 0xbf, 0x8f, 0xde, 0x15,
	0xdc, 0xc5, 0x35, 0x92, 0xa9, 0xbc, 0x52, 0xe2, 0x45, 0xeb, 0x79, 0x76, 0xdf, 0x9b, 0x7e, 0x74,
	0x5d, 0x51, 0x7b, 0xeb, 0x6d, 0xd7, 0x15, 0x17, 0xb3, 0xf6, 0xfd, 0x54, 0x99, 0xb4, 0x4f, 0x85,
	0xb4, 0x47, 0xf8, 0xa1, 0x29, 0xad, 0xeb, 0x6e, 0x64, 0x02, 0xbb, 0xee, 0x46, 0x26, 0xb3, 0xeb,
	0x6e, 0x58, 0x62, 0xd3, 0xef, 0xae, 0x2b, 0xbf, 0xd2, 0xf0, 0x7c, 0x01, 0x40, 0xe8, 0x20, 0x3c,
	0xa2, 0x42, 0x91, 0xf2, 0x5b, 0xe1, 0x32, 0x85, 0x36, 0x85, 0x42, 0x77, 0x6f, 0x7e, 0xf4, 0x72,
	0xe6, 0xeb, 0xd9, 0xfd, 0xf3, 0x8a, 0x2e, 0xb3, 0x67, 0x73, 0x44, 0xf3, 0x3b, 0x77, 0xc4, 0x2f,
	0x2a, 0xb0, 0xb0, 0x4d, 0xd9, 0xfd, 0xf0, 0x59, 0xe0, 0x87, 0x8e, 0x78, 0xb9, 0x3b, 0xc2, 0x1b,
	0x4b, 0xd6, 0xf0, 0xe3, 0xc8, 0xc7, 0x9f, 0x08, 0xa5, 0x1e, 0xa0, 0xad, 0x6f, 0xe5, 0x8c, 0x96,
	0xab, 0x64, 0xa3, 0x5f, 0x55, 0x60, 0x8e, 0x2f, 0x88, 0x43, 0xad, 0x49, 0xb6, 0x3c, 0xd8, 0xcf,
	0x59, 0x4a, 0x74, 0xf9, 0x99, 0xd0, 0xe5, 0x33, 0xbc, 0xfb, 0x5d, 0x3a, 0xa8, 0x95, 0x08, 0x91,
	0x3c, 0x77, 0xfe, 0x61, 0x4a, 0xbf, 0x14, 0x42, 0x43, 0xfd, 0x0a, 0x49, 0xed, 0x5f, 0x9a, 0x65,
	0xdd, 0xb5, 0xc4, 0x68, 0xe6, 0xde, 0x13, 0xe1, 0x77, 0x84, 0x9a, 0x1b, 0xf8, 0x0d, 0xd9, 0x6b,
	0x09, 0x86, 0x45, 0x3d, 0xa5, 0x70, 0xd9, 0x8a, 0xf3, 0x49, 0xfa, 0x63, 0x98, 0xe1, 0xcb, 0x88,
	0x14, 0x7f, 0xde, 0x66, 0x99, 0xd6, 0xb3, 0xb5, 0xc2, 0xb8, 0xaa, 0x64, 0xaf, 0x08, 0x99, 0x6b,
	0x68, 0xd5, 0x92, 0xa9, 0x05, 0xf2, 0x58, 0xbc, 0xa0, 0xec, 0x49, 0xf7, 0x11, 0xe9, 0xf6, 0x03,
	0x65, 0x27, 0x2a, 0x23, 0xde, 0x23, 0x15, 0x4c, 0x7c, 0x5f, 0x88, 0xbb, 0xd5, 0x5c, 0x3f, 0x8d,
	0x89, 0x29, 0x4f, 0x6e, 0xa6, 0x0f, 0x8b, 0xdb, 0xd4, 0x3e, 0xbe, 0x2c, 0x6c, 0x43, 0x9b, 0x39,
	0x6f, 0x9b, 0xd8, 0xb9, 0xf6, 0x2b, 0x6f, 0xa9, 0x8e, 0x37, 0x79, 0x22, 0x83, 0x62, 0x58, 0x6c,
	0xbb, 0xae, 0x25, 0x6d, 0x0c, 0xef, 0x6f, 0x35, 0x93, 0x52, 0x22, 0x37, 0x31, 0x84, 0x65, 0x3d,
	0x93, 0xd9, 0x06, 0xb8, 0x68, 0x64, 0x6e, 0x2e, 0xb3, 0xcd, 0x73, 0x4b, 0x48, 0x7d, 0x03, 0xbd,
	0x3e, 0xd6, 0xc2, 0x28, 0x09, 0xd6, 0xd5, 0x46, 0xee, 0x08, 0x96, 0x77, 0x0b, 0x02, 0x47, 0xb1,
	0xff, 0x56, 0x73, 0x99, 0x09, 0xe5, 0xf9, 0xd2, 0x4f, 0x9f, 0x53, 0xa2, 0x9f, 0x8a, 0x0a, 0xb3,
	0x95, 0xf8, 0xbe, 0x1e, 0xc9, 0xe4, 0xdb, 0x6f, 0x33, 0x9b, 0x97, 0xf2, 0x00, 0xf3, 0x89, 0x26,
	0x5e, 0x11, 0xda, 0x2c, 0xa0, 0x39, 0xa1, 0x8d, 0x3a, 0x6a, 0xea, 0xdc, 0x87, 0x8b, 0xbd, 0x70,
	0x90, 0x12, 0xf6, 0x7c, 0x8f, 0x06, 0x2c, 0xdd, 0x49, 0xff, 0x91, 0xfe, 0x2f, 0xac, 0xbf, 0xaf,
	0x8e, 0x43, 0xdb, 0x9f, 0x12, 0xbf, 0x6e, 0xff, 0x36, 0x00, 0x00, 0xff, 0xff, 0x8a, 0xf6, 0xf2,
	0x03, 0xc2, 0x35, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// AuthClient is the client API for Auth service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AuthClient interface {
	IsAuthorized(ctx context.Context, in *IsAuthorizedRequest, opts ...grpc.CallOption) (*IsAuthorizedResponse, error)
	LoginWithToken(ctx context.Context, in *ApiTokenLoginRequest, opts ...grpc.CallOption) (*LoginResponse, error)
	LoginWithCredentials(ctx context.Context, in *PlainUserLoginRequest, opts ...grpc.CallOption) (*LoginResponse, error)
	RefreshToken(ctx context.Context, in *RefreshTokenRequest, opts ...grpc.CallOption) (*LoginResponse, error)
}

type authClient struct {
	cc *grpc.ClientConn
}

func NewAuthClient(cc *grpc.ClientConn) AuthClient {
	return &authClient{cc}
}

func (c *authClient) IsAuthorized(ctx context.Context, in *IsAuthorizedRequest, opts ...grpc.CallOption) (*IsAuthorizedResponse, error) {
	out := new(IsAuthorizedResponse)
	err := c.cc.Invoke(ctx, "/slickqa.Auth/IsAuthorized", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *authClient) LoginWithToken(ctx context.Context, in *ApiTokenLoginRequest, opts ...grpc.CallOption) (*LoginResponse, error) {
	out := new(LoginResponse)
	err := c.cc.Invoke(ctx, "/slickqa.Auth/LoginWithToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *authClient) LoginWithCredentials(ctx context.Context, in *PlainUserLoginRequest, opts ...grpc.CallOption) (*LoginResponse, error) {
	out := new(LoginResponse)
	err := c.cc.Invoke(ctx, "/slickqa.Auth/LoginWithCredentials", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *authClient) RefreshToken(ctx context.Context, in *RefreshTokenRequest, opts ...grpc.CallOption) (*LoginResponse, error) {
	out := new(LoginResponse)
	err := c.cc.Invoke(ctx, "/slickqa.Auth/RefreshToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AuthServer is the server API for Auth service.
type AuthServer interface {
	IsAuthorized(context.Context, *IsAuthorizedRequest) (*IsAuthorizedResponse, error)
	LoginWithToken(context.Context, *ApiTokenLoginRequest) (*LoginResponse, error)
	LoginWithCredentials(context.Context, *PlainUserLoginRequest) (*LoginResponse, error)
	RefreshToken(context.Context, *RefreshTokenRequest) (*LoginResponse, error)
}

// UnimplementedAuthServer can be embedded to have forward compatible implementations.
type UnimplementedAuthServer struct {
}

func (*UnimplementedAuthServer) IsAuthorized(ctx context.Context, req *IsAuthorizedRequest) (*IsAuthorizedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IsAuthorized not implemented")
}
func (*UnimplementedAuthServer) LoginWithToken(ctx context.Context, req *ApiTokenLoginRequest) (*LoginResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LoginWithToken not implemented")
}
func (*UnimplementedAuthServer) LoginWithCredentials(ctx context.Context, req *PlainUserLoginRequest) (*LoginResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LoginWithCredentials not implemented")
}
func (*UnimplementedAuthServer) RefreshToken(ctx context.Context, req *RefreshTokenRequest) (*LoginResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RefreshToken not implemented")
}

func RegisterAuthServer(s *grpc.Server, srv AuthServer) {
	s.RegisterService(&_Auth_serviceDesc, srv)
}

func _Auth_IsAuthorized_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IsAuthorizedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AuthServer).IsAuthorized(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Auth/IsAuthorized",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AuthServer).IsAuthorized(ctx, req.(*IsAuthorizedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Auth_LoginWithToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApiTokenLoginRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AuthServer).LoginWithToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Auth/LoginWithToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AuthServer).LoginWithToken(ctx, req.(*ApiTokenLoginRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Auth_LoginWithCredentials_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PlainUserLoginRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AuthServer).LoginWithCredentials(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Auth/LoginWithCredentials",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AuthServer).LoginWithCredentials(ctx, req.(*PlainUserLoginRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Auth_RefreshToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RefreshTokenRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AuthServer).RefreshToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Auth/RefreshToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AuthServer).RefreshToken(ctx, req.(*RefreshTokenRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Auth_serviceDesc = grpc.ServiceDesc{
	ServiceName: "slickqa.Auth",
	HandlerType: (*AuthServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "IsAuthorized",
			Handler:    _Auth_IsAuthorized_Handler,
		},
		{
			MethodName: "LoginWithToken",
			Handler:    _Auth_LoginWithToken_Handler,
		},
		{
			MethodName: "LoginWithCredentials",
			Handler:    _Auth_LoginWithCredentials_Handler,
		},
		{
			MethodName: "RefreshToken",
			Handler:    _Auth_RefreshToken_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "slick.proto",
}

// UsersClient is the client API for Users service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type UsersClient interface {
	GetCurrentUserInfo(ctx context.Context, in *CurrentUserRequest, opts ...grpc.CallOption) (*UserInfo, error)
	GetUserInfo(ctx context.Context, in *UserInfoRequest, opts ...grpc.CallOption) (*UserInfo, error)
	GetUsersForCompany(ctx context.Context, in *UsersForCompanyQueryRequest, opts ...grpc.CallOption) (*UsersQueryResponse, error)
	GetUsersForProject(ctx context.Context, in *UsersForProjectQueryRequest, opts ...grpc.CallOption) (*UsersQueryResponse, error)
	UpdateUser(ctx context.Context, in *UserInfo, opts ...grpc.CallOption) (*UserInfo, error)
	AddUserToCompany(ctx context.Context, in *AddUserRequest, opts ...grpc.CallOption) (*UserInfo, error)
}

type usersClient struct {
	cc *grpc.ClientConn
}

func NewUsersClient(cc *grpc.ClientConn) UsersClient {
	return &usersClient{cc}
}

func (c *usersClient) GetCurrentUserInfo(ctx context.Context, in *CurrentUserRequest, opts ...grpc.CallOption) (*UserInfo, error) {
	out := new(UserInfo)
	err := c.cc.Invoke(ctx, "/slickqa.Users/GetCurrentUserInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *usersClient) GetUserInfo(ctx context.Context, in *UserInfoRequest, opts ...grpc.CallOption) (*UserInfo, error) {
	out := new(UserInfo)
	err := c.cc.Invoke(ctx, "/slickqa.Users/GetUserInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *usersClient) GetUsersForCompany(ctx context.Context, in *UsersForCompanyQueryRequest, opts ...grpc.CallOption) (*UsersQueryResponse, error) {
	out := new(UsersQueryResponse)
	err := c.cc.Invoke(ctx, "/slickqa.Users/GetUsersForCompany", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *usersClient) GetUsersForProject(ctx context.Context, in *UsersForProjectQueryRequest, opts ...grpc.CallOption) (*UsersQueryResponse, error) {
	out := new(UsersQueryResponse)
	err := c.cc.Invoke(ctx, "/slickqa.Users/GetUsersForProject", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *usersClient) UpdateUser(ctx context.Context, in *UserInfo, opts ...grpc.CallOption) (*UserInfo, error) {
	out := new(UserInfo)
	err := c.cc.Invoke(ctx, "/slickqa.Users/UpdateUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *usersClient) AddUserToCompany(ctx context.Context, in *AddUserRequest, opts ...grpc.CallOption) (*UserInfo, error) {
	out := new(UserInfo)
	err := c.cc.Invoke(ctx, "/slickqa.Users/AddUserToCompany", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// UsersServer is the server API for Users service.
type UsersServer interface {
	GetCurrentUserInfo(context.Context, *CurrentUserRequest) (*UserInfo, error)
	GetUserInfo(context.Context, *UserInfoRequest) (*UserInfo, error)
	GetUsersForCompany(context.Context, *UsersForCompanyQueryRequest) (*UsersQueryResponse, error)
	GetUsersForProject(context.Context, *UsersForProjectQueryRequest) (*UsersQueryResponse, error)
	UpdateUser(context.Context, *UserInfo) (*UserInfo, error)
	AddUserToCompany(context.Context, *AddUserRequest) (*UserInfo, error)
}

// UnimplementedUsersServer can be embedded to have forward compatible implementations.
type UnimplementedUsersServer struct {
}

func (*UnimplementedUsersServer) GetCurrentUserInfo(ctx context.Context, req *CurrentUserRequest) (*UserInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCurrentUserInfo not implemented")
}
func (*UnimplementedUsersServer) GetUserInfo(ctx context.Context, req *UserInfoRequest) (*UserInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetUserInfo not implemented")
}
func (*UnimplementedUsersServer) GetUsersForCompany(ctx context.Context, req *UsersForCompanyQueryRequest) (*UsersQueryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetUsersForCompany not implemented")
}
func (*UnimplementedUsersServer) GetUsersForProject(ctx context.Context, req *UsersForProjectQueryRequest) (*UsersQueryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetUsersForProject not implemented")
}
func (*UnimplementedUsersServer) UpdateUser(ctx context.Context, req *UserInfo) (*UserInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateUser not implemented")
}
func (*UnimplementedUsersServer) AddUserToCompany(ctx context.Context, req *AddUserRequest) (*UserInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddUserToCompany not implemented")
}

func RegisterUsersServer(s *grpc.Server, srv UsersServer) {
	s.RegisterService(&_Users_serviceDesc, srv)
}

func _Users_GetCurrentUserInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CurrentUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UsersServer).GetCurrentUserInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Users/GetCurrentUserInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UsersServer).GetCurrentUserInfo(ctx, req.(*CurrentUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Users_GetUserInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UsersServer).GetUserInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Users/GetUserInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UsersServer).GetUserInfo(ctx, req.(*UserInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Users_GetUsersForCompany_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UsersForCompanyQueryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UsersServer).GetUsersForCompany(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Users/GetUsersForCompany",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UsersServer).GetUsersForCompany(ctx, req.(*UsersForCompanyQueryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Users_GetUsersForProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UsersForProjectQueryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UsersServer).GetUsersForProject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Users/GetUsersForProject",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UsersServer).GetUsersForProject(ctx, req.(*UsersForProjectQueryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Users_UpdateUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UsersServer).UpdateUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Users/UpdateUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UsersServer).UpdateUser(ctx, req.(*UserInfo))
	}
	return interceptor(ctx, in, info, handler)
}

func _Users_AddUserToCompany_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UsersServer).AddUserToCompany(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Users/AddUserToCompany",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UsersServer).AddUserToCompany(ctx, req.(*AddUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Users_serviceDesc = grpc.ServiceDesc{
	ServiceName: "slickqa.Users",
	HandlerType: (*UsersServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetCurrentUserInfo",
			Handler:    _Users_GetCurrentUserInfo_Handler,
		},
		{
			MethodName: "GetUserInfo",
			Handler:    _Users_GetUserInfo_Handler,
		},
		{
			MethodName: "GetUsersForCompany",
			Handler:    _Users_GetUsersForCompany_Handler,
		},
		{
			MethodName: "GetUsersForProject",
			Handler:    _Users_GetUsersForProject_Handler,
		},
		{
			MethodName: "UpdateUser",
			Handler:    _Users_UpdateUser_Handler,
		},
		{
			MethodName: "AddUserToCompany",
			Handler:    _Users_AddUserToCompany_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "slick.proto",
}

// CompanyClient is the client API for Company service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type CompanyClient interface {
	GetCompanySettings(ctx context.Context, in *CompanySettingsRequest, opts ...grpc.CallOption) (*CompanySettings, error)
	GetAvailableCompanySettings(ctx context.Context, in *AvailableCompanySettingsRequest, opts ...grpc.CallOption) (*AvailableCompanySettings, error)
	UpdateCompanySettings(ctx context.Context, in *CompanySettings, opts ...grpc.CallOption) (*CompanySettings, error)
	AddCompanySettings(ctx context.Context, in *CompanySettingsRequest, opts ...grpc.CallOption) (*CompanySettings, error)
}

type companyClient struct {
	cc *grpc.ClientConn
}

func NewCompanyClient(cc *grpc.ClientConn) CompanyClient {
	return &companyClient{cc}
}

func (c *companyClient) GetCompanySettings(ctx context.Context, in *CompanySettingsRequest, opts ...grpc.CallOption) (*CompanySettings, error) {
	out := new(CompanySettings)
	err := c.cc.Invoke(ctx, "/slickqa.Company/GetCompanySettings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companyClient) GetAvailableCompanySettings(ctx context.Context, in *AvailableCompanySettingsRequest, opts ...grpc.CallOption) (*AvailableCompanySettings, error) {
	out := new(AvailableCompanySettings)
	err := c.cc.Invoke(ctx, "/slickqa.Company/GetAvailableCompanySettings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companyClient) UpdateCompanySettings(ctx context.Context, in *CompanySettings, opts ...grpc.CallOption) (*CompanySettings, error) {
	out := new(CompanySettings)
	err := c.cc.Invoke(ctx, "/slickqa.Company/UpdateCompanySettings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *companyClient) AddCompanySettings(ctx context.Context, in *CompanySettingsRequest, opts ...grpc.CallOption) (*CompanySettings, error) {
	out := new(CompanySettings)
	err := c.cc.Invoke(ctx, "/slickqa.Company/AddCompanySettings", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CompanyServer is the server API for Company service.
type CompanyServer interface {
	GetCompanySettings(context.Context, *CompanySettingsRequest) (*CompanySettings, error)
	GetAvailableCompanySettings(context.Context, *AvailableCompanySettingsRequest) (*AvailableCompanySettings, error)
	UpdateCompanySettings(context.Context, *CompanySettings) (*CompanySettings, error)
	AddCompanySettings(context.Context, *CompanySettingsRequest) (*CompanySettings, error)
}

// UnimplementedCompanyServer can be embedded to have forward compatible implementations.
type UnimplementedCompanyServer struct {
}

func (*UnimplementedCompanyServer) GetCompanySettings(ctx context.Context, req *CompanySettingsRequest) (*CompanySettings, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCompanySettings not implemented")
}
func (*UnimplementedCompanyServer) GetAvailableCompanySettings(ctx context.Context, req *AvailableCompanySettingsRequest) (*AvailableCompanySettings, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAvailableCompanySettings not implemented")
}
func (*UnimplementedCompanyServer) UpdateCompanySettings(ctx context.Context, req *CompanySettings) (*CompanySettings, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateCompanySettings not implemented")
}
func (*UnimplementedCompanyServer) AddCompanySettings(ctx context.Context, req *CompanySettingsRequest) (*CompanySettings, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddCompanySettings not implemented")
}

func RegisterCompanyServer(s *grpc.Server, srv CompanyServer) {
	s.RegisterService(&_Company_serviceDesc, srv)
}

func _Company_GetCompanySettings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CompanySettingsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanyServer).GetCompanySettings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Company/GetCompanySettings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanyServer).GetCompanySettings(ctx, req.(*CompanySettingsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Company_GetAvailableCompanySettings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AvailableCompanySettingsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanyServer).GetAvailableCompanySettings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Company/GetAvailableCompanySettings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanyServer).GetAvailableCompanySettings(ctx, req.(*AvailableCompanySettingsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Company_UpdateCompanySettings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CompanySettings)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanyServer).UpdateCompanySettings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Company/UpdateCompanySettings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanyServer).UpdateCompanySettings(ctx, req.(*CompanySettings))
	}
	return interceptor(ctx, in, info, handler)
}

func _Company_AddCompanySettings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CompanySettingsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CompanyServer).AddCompanySettings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Company/AddCompanySettings",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CompanyServer).AddCompanySettings(ctx, req.(*CompanySettingsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Company_serviceDesc = grpc.ServiceDesc{
	ServiceName: "slickqa.Company",
	HandlerType: (*CompanyServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetCompanySettings",
			Handler:    _Company_GetCompanySettings_Handler,
		},
		{
			MethodName: "GetAvailableCompanySettings",
			Handler:    _Company_GetAvailableCompanySettings_Handler,
		},
		{
			MethodName: "UpdateCompanySettings",
			Handler:    _Company_UpdateCompanySettings_Handler,
		},
		{
			MethodName: "AddCompanySettings",
			Handler:    _Company_AddCompanySettings_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "slick.proto",
}

// ProjectsClient is the client API for Projects service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ProjectsClient interface {
	GetProjects(ctx context.Context, in *ProjectsRequest, opts ...grpc.CallOption) (*ProjectsListResponse, error)
	GetProjectByName(ctx context.Context, in *ProjectIdentity, opts ...grpc.CallOption) (*Project, error)
	AddProject(ctx context.Context, in *ProjectIdentity, opts ...grpc.CallOption) (*Project, error)
}

type projectsClient struct {
	cc *grpc.ClientConn
}

func NewProjectsClient(cc *grpc.ClientConn) ProjectsClient {
	return &projectsClient{cc}
}

func (c *projectsClient) GetProjects(ctx context.Context, in *ProjectsRequest, opts ...grpc.CallOption) (*ProjectsListResponse, error) {
	out := new(ProjectsListResponse)
	err := c.cc.Invoke(ctx, "/slickqa.Projects/GetProjects", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *projectsClient) GetProjectByName(ctx context.Context, in *ProjectIdentity, opts ...grpc.CallOption) (*Project, error) {
	out := new(Project)
	err := c.cc.Invoke(ctx, "/slickqa.Projects/GetProjectByName", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *projectsClient) AddProject(ctx context.Context, in *ProjectIdentity, opts ...grpc.CallOption) (*Project, error) {
	out := new(Project)
	err := c.cc.Invoke(ctx, "/slickqa.Projects/AddProject", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ProjectsServer is the server API for Projects service.
type ProjectsServer interface {
	GetProjects(context.Context, *ProjectsRequest) (*ProjectsListResponse, error)
	GetProjectByName(context.Context, *ProjectIdentity) (*Project, error)
	AddProject(context.Context, *ProjectIdentity) (*Project, error)
}

// UnimplementedProjectsServer can be embedded to have forward compatible implementations.
type UnimplementedProjectsServer struct {
}

func (*UnimplementedProjectsServer) GetProjects(ctx context.Context, req *ProjectsRequest) (*ProjectsListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetProjects not implemented")
}
func (*UnimplementedProjectsServer) GetProjectByName(ctx context.Context, req *ProjectIdentity) (*Project, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetProjectByName not implemented")
}
func (*UnimplementedProjectsServer) AddProject(ctx context.Context, req *ProjectIdentity) (*Project, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddProject not implemented")
}

func RegisterProjectsServer(s *grpc.Server, srv ProjectsServer) {
	s.RegisterService(&_Projects_serviceDesc, srv)
}

func _Projects_GetProjects_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProjectsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectsServer).GetProjects(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Projects/GetProjects",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectsServer).GetProjects(ctx, req.(*ProjectsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Projects_GetProjectByName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProjectIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectsServer).GetProjectByName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Projects/GetProjectByName",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectsServer).GetProjectByName(ctx, req.(*ProjectIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Projects_AddProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ProjectIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ProjectsServer).AddProject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Projects/AddProject",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ProjectsServer).AddProject(ctx, req.(*ProjectIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

var _Projects_serviceDesc = grpc.ServiceDesc{
	ServiceName: "slickqa.Projects",
	HandlerType: (*ProjectsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetProjects",
			Handler:    _Projects_GetProjects_Handler,
		},
		{
			MethodName: "GetProjectByName",
			Handler:    _Projects_GetProjectByName_Handler,
		},
		{
			MethodName: "AddProject",
			Handler:    _Projects_AddProject_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "slick.proto",
}

// LinksClient is the client API for Links service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type LinksClient interface {
	GetLinks(ctx context.Context, in *LinkListIdentity, opts ...grpc.CallOption) (*LinkList, error)
	AddLink(ctx context.Context, in *Link, opts ...grpc.CallOption) (*LinkList, error)
	RemoveLink(ctx context.Context, in *LinkIdentity, opts ...grpc.CallOption) (*LinkList, error)
	UpdateLink(ctx context.Context, in *Link, opts ...grpc.CallOption) (*LinkList, error)
	GetDownloadUrl(ctx context.Context, in *LinkIdentity, opts ...grpc.CallOption) (*LinkUrl, error)
	GetUploadUrl(ctx context.Context, in *FileUploadInfo, opts ...grpc.CallOption) (*LinkUrl, error)
}

type linksClient struct {
	cc *grpc.ClientConn
}

func NewLinksClient(cc *grpc.ClientConn) LinksClient {
	return &linksClient{cc}
}

func (c *linksClient) GetLinks(ctx context.Context, in *LinkListIdentity, opts ...grpc.CallOption) (*LinkList, error) {
	out := new(LinkList)
	err := c.cc.Invoke(ctx, "/slickqa.Links/GetLinks", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *linksClient) AddLink(ctx context.Context, in *Link, opts ...grpc.CallOption) (*LinkList, error) {
	out := new(LinkList)
	err := c.cc.Invoke(ctx, "/slickqa.Links/AddLink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *linksClient) RemoveLink(ctx context.Context, in *LinkIdentity, opts ...grpc.CallOption) (*LinkList, error) {
	out := new(LinkList)
	err := c.cc.Invoke(ctx, "/slickqa.Links/RemoveLink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *linksClient) UpdateLink(ctx context.Context, in *Link, opts ...grpc.CallOption) (*LinkList, error) {
	out := new(LinkList)
	err := c.cc.Invoke(ctx, "/slickqa.Links/UpdateLink", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *linksClient) GetDownloadUrl(ctx context.Context, in *LinkIdentity, opts ...grpc.CallOption) (*LinkUrl, error) {
	out := new(LinkUrl)
	err := c.cc.Invoke(ctx, "/slickqa.Links/GetDownloadUrl", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *linksClient) GetUploadUrl(ctx context.Context, in *FileUploadInfo, opts ...grpc.CallOption) (*LinkUrl, error) {
	out := new(LinkUrl)
	err := c.cc.Invoke(ctx, "/slickqa.Links/GetUploadUrl", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LinksServer is the server API for Links service.
type LinksServer interface {
	GetLinks(context.Context, *LinkListIdentity) (*LinkList, error)
	AddLink(context.Context, *Link) (*LinkList, error)
	RemoveLink(context.Context, *LinkIdentity) (*LinkList, error)
	UpdateLink(context.Context, *Link) (*LinkList, error)
	GetDownloadUrl(context.Context, *LinkIdentity) (*LinkUrl, error)
	GetUploadUrl(context.Context, *FileUploadInfo) (*LinkUrl, error)
}

// UnimplementedLinksServer can be embedded to have forward compatible implementations.
type UnimplementedLinksServer struct {
}

func (*UnimplementedLinksServer) GetLinks(ctx context.Context, req *LinkListIdentity) (*LinkList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLinks not implemented")
}
func (*UnimplementedLinksServer) AddLink(ctx context.Context, req *Link) (*LinkList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddLink not implemented")
}
func (*UnimplementedLinksServer) RemoveLink(ctx context.Context, req *LinkIdentity) (*LinkList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveLink not implemented")
}
func (*UnimplementedLinksServer) UpdateLink(ctx context.Context, req *Link) (*LinkList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateLink not implemented")
}
func (*UnimplementedLinksServer) GetDownloadUrl(ctx context.Context, req *LinkIdentity) (*LinkUrl, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDownloadUrl not implemented")
}
func (*UnimplementedLinksServer) GetUploadUrl(ctx context.Context, req *FileUploadInfo) (*LinkUrl, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetUploadUrl not implemented")
}

func RegisterLinksServer(s *grpc.Server, srv LinksServer) {
	s.RegisterService(&_Links_serviceDesc, srv)
}

func _Links_GetLinks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LinkListIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LinksServer).GetLinks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Links/GetLinks",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LinksServer).GetLinks(ctx, req.(*LinkListIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Links_AddLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Link)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LinksServer).AddLink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Links/AddLink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LinksServer).AddLink(ctx, req.(*Link))
	}
	return interceptor(ctx, in, info, handler)
}

func _Links_RemoveLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LinkIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LinksServer).RemoveLink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Links/RemoveLink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LinksServer).RemoveLink(ctx, req.(*LinkIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Links_UpdateLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Link)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LinksServer).UpdateLink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Links/UpdateLink",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LinksServer).UpdateLink(ctx, req.(*Link))
	}
	return interceptor(ctx, in, info, handler)
}

func _Links_GetDownloadUrl_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LinkIdentity)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LinksServer).GetDownloadUrl(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Links/GetDownloadUrl",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LinksServer).GetDownloadUrl(ctx, req.(*LinkIdentity))
	}
	return interceptor(ctx, in, info, handler)
}

func _Links_GetUploadUrl_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FileUploadInfo)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LinksServer).GetUploadUrl(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Links/GetUploadUrl",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LinksServer).GetUploadUrl(ctx, req.(*FileUploadInfo))
	}
	return interceptor(ctx, in, info, handler)
}

var _Links_serviceDesc = grpc.ServiceDesc{
	ServiceName: "slickqa.Links",
	HandlerType: (*LinksServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetLinks",
			Handler:    _Links_GetLinks_Handler,
		},
		{
			MethodName: "AddLink",
			Handler:    _Links_AddLink_Handler,
		},
		{
			MethodName: "RemoveLink",
			Handler:    _Links_RemoveLink_Handler,
		},
		{
			MethodName: "UpdateLink",
			Handler:    _Links_UpdateLink_Handler,
		},
		{
			MethodName: "GetDownloadUrl",
			Handler:    _Links_GetDownloadUrl_Handler,
		},
		{
			MethodName: "GetUploadUrl",
			Handler:    _Links_GetUploadUrl_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "slick.proto",
}

// AgentsClient is the client API for Agents service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AgentsClient interface {
	UpdateStatus(ctx context.Context, in *AgentStatusUpdate, opts ...grpc.CallOption) (*Agent, error)
	GetAgents(ctx context.Context, in *AgentsRequest, opts ...grpc.CallOption) (*AgentsResponse, error)
	UpdateScreenshotTimestamp(ctx context.Context, in *ScreenshotUpdateRequest, opts ...grpc.CallOption) (*Agent, error)
	GetQueuedAction(ctx context.Context, in *AgentId, opts ...grpc.CallOption) (*AgentQueuedAction, error)
	AddQueuedAction(ctx context.Context, in *AgentQueuedAction, opts ...grpc.CallOption) (*Agent, error)
	GetAgentRunStatus(ctx context.Context, in *AgentId, opts ...grpc.CallOption) (*AgentRunStatus, error)
	SetAgentRunStatus(ctx context.Context, in *AgentRunStatus, opts ...grpc.CallOption) (*Agent, error)
}

type agentsClient struct {
	cc *grpc.ClientConn
}

func NewAgentsClient(cc *grpc.ClientConn) AgentsClient {
	return &agentsClient{cc}
}

func (c *agentsClient) UpdateStatus(ctx context.Context, in *AgentStatusUpdate, opts ...grpc.CallOption) (*Agent, error) {
	out := new(Agent)
	err := c.cc.Invoke(ctx, "/slickqa.Agents/UpdateStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentsClient) GetAgents(ctx context.Context, in *AgentsRequest, opts ...grpc.CallOption) (*AgentsResponse, error) {
	out := new(AgentsResponse)
	err := c.cc.Invoke(ctx, "/slickqa.Agents/GetAgents", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentsClient) UpdateScreenshotTimestamp(ctx context.Context, in *ScreenshotUpdateRequest, opts ...grpc.CallOption) (*Agent, error) {
	out := new(Agent)
	err := c.cc.Invoke(ctx, "/slickqa.Agents/UpdateScreenshotTimestamp", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentsClient) GetQueuedAction(ctx context.Context, in *AgentId, opts ...grpc.CallOption) (*AgentQueuedAction, error) {
	out := new(AgentQueuedAction)
	err := c.cc.Invoke(ctx, "/slickqa.Agents/GetQueuedAction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentsClient) AddQueuedAction(ctx context.Context, in *AgentQueuedAction, opts ...grpc.CallOption) (*Agent, error) {
	out := new(Agent)
	err := c.cc.Invoke(ctx, "/slickqa.Agents/AddQueuedAction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentsClient) GetAgentRunStatus(ctx context.Context, in *AgentId, opts ...grpc.CallOption) (*AgentRunStatus, error) {
	out := new(AgentRunStatus)
	err := c.cc.Invoke(ctx, "/slickqa.Agents/GetAgentRunStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agentsClient) SetAgentRunStatus(ctx context.Context, in *AgentRunStatus, opts ...grpc.CallOption) (*Agent, error) {
	out := new(Agent)
	err := c.cc.Invoke(ctx, "/slickqa.Agents/SetAgentRunStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AgentsServer is the server API for Agents service.
type AgentsServer interface {
	UpdateStatus(context.Context, *AgentStatusUpdate) (*Agent, error)
	GetAgents(context.Context, *AgentsRequest) (*AgentsResponse, error)
	UpdateScreenshotTimestamp(context.Context, *ScreenshotUpdateRequest) (*Agent, error)
	GetQueuedAction(context.Context, *AgentId) (*AgentQueuedAction, error)
	AddQueuedAction(context.Context, *AgentQueuedAction) (*Agent, error)
	GetAgentRunStatus(context.Context, *AgentId) (*AgentRunStatus, error)
	SetAgentRunStatus(context.Context, *AgentRunStatus) (*Agent, error)
}

// UnimplementedAgentsServer can be embedded to have forward compatible implementations.
type UnimplementedAgentsServer struct {
}

func (*UnimplementedAgentsServer) UpdateStatus(ctx context.Context, req *AgentStatusUpdate) (*Agent, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateStatus not implemented")
}
func (*UnimplementedAgentsServer) GetAgents(ctx context.Context, req *AgentsRequest) (*AgentsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAgents not implemented")
}
func (*UnimplementedAgentsServer) UpdateScreenshotTimestamp(ctx context.Context, req *ScreenshotUpdateRequest) (*Agent, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateScreenshotTimestamp not implemented")
}
func (*UnimplementedAgentsServer) GetQueuedAction(ctx context.Context, req *AgentId) (*AgentQueuedAction, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetQueuedAction not implemented")
}
func (*UnimplementedAgentsServer) AddQueuedAction(ctx context.Context, req *AgentQueuedAction) (*Agent, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddQueuedAction not implemented")
}
func (*UnimplementedAgentsServer) GetAgentRunStatus(ctx context.Context, req *AgentId) (*AgentRunStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAgentRunStatus not implemented")
}
func (*UnimplementedAgentsServer) SetAgentRunStatus(ctx context.Context, req *AgentRunStatus) (*Agent, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetAgentRunStatus not implemented")
}

func RegisterAgentsServer(s *grpc.Server, srv AgentsServer) {
	s.RegisterService(&_Agents_serviceDesc, srv)
}

func _Agents_UpdateStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AgentStatusUpdate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentsServer).UpdateStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Agents/UpdateStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentsServer).UpdateStatus(ctx, req.(*AgentStatusUpdate))
	}
	return interceptor(ctx, in, info, handler)
}

func _Agents_GetAgents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AgentsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentsServer).GetAgents(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Agents/GetAgents",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentsServer).GetAgents(ctx, req.(*AgentsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Agents_UpdateScreenshotTimestamp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ScreenshotUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentsServer).UpdateScreenshotTimestamp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Agents/UpdateScreenshotTimestamp",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentsServer).UpdateScreenshotTimestamp(ctx, req.(*ScreenshotUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Agents_GetQueuedAction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AgentId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentsServer).GetQueuedAction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Agents/GetQueuedAction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentsServer).GetQueuedAction(ctx, req.(*AgentId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Agents_AddQueuedAction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AgentQueuedAction)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentsServer).AddQueuedAction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Agents/AddQueuedAction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentsServer).AddQueuedAction(ctx, req.(*AgentQueuedAction))
	}
	return interceptor(ctx, in, info, handler)
}

func _Agents_GetAgentRunStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AgentId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentsServer).GetAgentRunStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Agents/GetAgentRunStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentsServer).GetAgentRunStatus(ctx, req.(*AgentId))
	}
	return interceptor(ctx, in, info, handler)
}

func _Agents_SetAgentRunStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AgentRunStatus)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgentsServer).SetAgentRunStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Agents/SetAgentRunStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgentsServer).SetAgentRunStatus(ctx, req.(*AgentRunStatus))
	}
	return interceptor(ctx, in, info, handler)
}

var _Agents_serviceDesc = grpc.ServiceDesc{
	ServiceName: "slickqa.Agents",
	HandlerType: (*AgentsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "UpdateStatus",
			Handler:    _Agents_UpdateStatus_Handler,
		},
		{
			MethodName: "GetAgents",
			Handler:    _Agents_GetAgents_Handler,
		},
		{
			MethodName: "UpdateScreenshotTimestamp",
			Handler:    _Agents_UpdateScreenshotTimestamp_Handler,
		},
		{
			MethodName: "GetQueuedAction",
			Handler:    _Agents_GetQueuedAction_Handler,
		},
		{
			MethodName: "AddQueuedAction",
			Handler:    _Agents_AddQueuedAction_Handler,
		},
		{
			MethodName: "GetAgentRunStatus",
			Handler:    _Agents_GetAgentRunStatus_Handler,
		},
		{
			MethodName: "SetAgentRunStatus",
			Handler:    _Agents_SetAgentRunStatus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "slick.proto",
}

// VersionClient is the client API for Version service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VersionClient interface {
	GetFullVersion(ctx context.Context, in *VersionRequest, opts ...grpc.CallOption) (*VersionInfoResponse, error)
}

type versionClient struct {
	cc *grpc.ClientConn
}

func NewVersionClient(cc *grpc.ClientConn) VersionClient {
	return &versionClient{cc}
}

func (c *versionClient) GetFullVersion(ctx context.Context, in *VersionRequest, opts ...grpc.CallOption) (*VersionInfoResponse, error) {
	out := new(VersionInfoResponse)
	err := c.cc.Invoke(ctx, "/slickqa.Version/GetFullVersion", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VersionServer is the server API for Version service.
type VersionServer interface {
	GetFullVersion(context.Context, *VersionRequest) (*VersionInfoResponse, error)
}

// UnimplementedVersionServer can be embedded to have forward compatible implementations.
type UnimplementedVersionServer struct {
}

func (*UnimplementedVersionServer) GetFullVersion(ctx context.Context, req *VersionRequest) (*VersionInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetFullVersion not implemented")
}

func RegisterVersionServer(s *grpc.Server, srv VersionServer) {
	s.RegisterService(&_Version_serviceDesc, srv)
}

func _Version_GetFullVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(VersionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VersionServer).GetFullVersion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slickqa.Version/GetFullVersion",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VersionServer).GetFullVersion(ctx, req.(*VersionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Version_serviceDesc = grpc.ServiceDesc{
	ServiceName: "slickqa.Version",
	HandlerType: (*VersionServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetFullVersion",
			Handler:    _Version_GetFullVersion_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "slick.proto",
}

license_type: permissive

branch_name: refs/heads/master

extension: go


text:
/**
 * Copyright (c) 2013-2015, Damian Vicino
 * Carleton University, Universite de Nice-Sophia Antipolis
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#define BOOST_TEST_DYN_LINK
#include <string>
#include <iostream>
#include <sstream>
#include <boost/test/unit_test.hpp>
#include <boost/any.hpp>
#include <boost/simulation/pdevs/basic_models/istream.hpp>
#include <math.h>

using namespace boost::simulation;
using namespace boost::simulation::pdevs;
using namespace boost::simulation::pdevs::basic_models;
using namespace std;

using Time=double;
using Message=boost::any;

BOOST_AUTO_TEST_SUITE( pistream_test_suite )
BOOST_AUTO_TEST_CASE( pistream_simple_of_single_events_test )
{
    //Create a istream with events every second outputing [1..10]
    //Check that outputs the 10 numbers every 1 second and last one is infinity

    shared_ptr<istringstream> piss{ new istringstream{} };
    piss->str("0 0");
    //init
    istream<Time, Message, int, int> pf{piss, Time(0)};
    BOOST_CHECK_EQUAL(pf.advance(), Time(0));

    // only message
    BOOST_REQUIRE_EQUAL(pf.out().size(), 1);
    BOOST_CHECK_EQUAL(boost::any_cast<int>(pf.out()[0]), 0);
    pf.internal();
    BOOST_CHECK( isinf(pf.advance()));
}

BOOST_AUTO_TEST_CASE( pistream_simple_of_multiple_events_test )
{
    //Create a istream with events every second outputing [1..10]
    //Check that outputs the 10 numbers every 1 second and last one is infinity

    shared_ptr<istringstream> piss{ new istringstream{} };
    piss->str("0 0 \n 0 1 \n 0 2 ");
    //init
    istream<Time, Message, int, int> pf{piss, Time(0)};
    BOOST_CHECK_EQUAL(pf.advance(), Time(0));

    // only output
    BOOST_REQUIRE_EQUAL(pf.out().size(), 3);
    pf.internal();
    BOOST_CHECK( isinf(pf.advance()));
}

BOOST_AUTO_TEST_CASE( pistream_as_generator_of_single_events_test )
{
    //Create a istream with events every second outputing [1..10]
    //Check that outputs the 10 numbers every 1 second and last one is infinity

    shared_ptr<istringstream> piss{ new istringstream{} };
    piss->str("0 0 \n 1 1 \n 2 2 \n 3 3 \n 4 4 \n 5 5 \n 6 6 \n 7 7 \n 8 8 \n 9 9 \n 10 10");
    //init
    istream<Time, Message, int, int> pf{piss, Time(0)};
    BOOST_CHECK_EQUAL(pf.advance(), Time(0));

    //consume
    for (int i=0; i < 10 ; i++){
        BOOST_REQUIRE_EQUAL(pf.out().size(), 1);
        BOOST_CHECK_EQUAL(boost::any_cast<int>(pf.out()[0]), i);
        pf.internal();
        BOOST_CHECK_EQUAL(pf.advance(), Time(1));
    }
    //last message
    BOOST_REQUIRE_EQUAL(pf.out().size(), 1);
    BOOST_CHECK_EQUAL(boost::any_cast<int>(pf.out()[0]), 10);
    pf.internal();
    BOOST_CHECK( isinf(pf.advance()));
}

BOOST_AUTO_TEST_CASE( pistream_as_generator_of_multiple_events_test )
{
    //Create a istream with events every second outputing [1..10]
    //Check that outputs the 10 numbers every 1 second and last one is infinity

    shared_ptr<istringstream> piss{ new istringstream{} };
    piss->str("1 1 \n 1 1 \n 2 2 \n 2 2 \n 3 3 \n 3 3 \n 4 4 \n 4 4 \n 5 5 \n 5 5");
    //init
    istream<Time, Message, int, int> pf{piss, Time(0)};
    BOOST_CHECK_EQUAL(pf.advance(), Time(1));
    //advance simulation
    for (int i=1; i < 5; i++){
        BOOST_REQUIRE_EQUAL(pf.out().size(), 2);
        BOOST_CHECK_EQUAL(boost::any_cast<int>(pf.out()[0]), i);
        BOOST_CHECK_EQUAL(boost::any_cast<int>(pf.out()[1]), i);
        pf.internal();
        BOOST_CHECK_EQUAL(pf.advance(), Time(1));
    }
    //last item
    BOOST_REQUIRE_EQUAL(pf.out().size(), 2);
    BOOST_CHECK_EQUAL(boost::any_cast<int>(pf.out()[0]), 5);
    BOOST_CHECK_EQUAL(boost::any_cast<int>(pf.out()[1]), 5);
    pf.internal();
    BOOST_CHECK( isinf(pf.advance()));
}

//custom processor of input
BOOST_AUTO_TEST_CASE( pistream_with_custom_processor_as_generator_of_multiple_events_test )
{
    //Create a istream with events every second outputing [1..10]
    //Check that outputs the 10 numbers every 1 second and last one is infinity

    shared_ptr<istringstream> piss{ new istringstream{} };
    piss->str("1 hello \n 1 world \n 2 hello \n 2 world");
    //init
    istream<Time, Message, int, int> pf{piss, Time(0),
                [](const string& s, Time& t_next, boost::any& m_next)->void{
            //intermediary vars for casting
            int tmp_next;
            string tmp_next_out;
            std::stringstream ss;
            ss.str(s);
            ss >> tmp_next;
            t_next = static_cast<Time>(tmp_next);
            ss >> tmp_next_out;
            m_next = static_cast<boost::any>(tmp_next_out);
            std::string thrash;
            ss >> thrash;
            if ( 0 != thrash.size()) throw std::exception();
        }};

    BOOST_CHECK_EQUAL(pf.advance(), Time(1));
    //advance simulation
    BOOST_REQUIRE_EQUAL(pf.out().size(), 2);
    BOOST_CHECK(any_of(pf.out().begin(), pf.out().end(), [](const boost::any& m ){ string s = boost::any_cast<string>(m); return s.compare("hello")==0;}));
    BOOST_CHECK(any_of(pf.out().begin(), pf.out().end(), [](const boost::any& m ){ string s = boost::any_cast<string>(m); return s.compare("world")==0;}));
    pf.internal();
    BOOST_CHECK_EQUAL(pf.advance(), Time(1));
    //last item
    BOOST_REQUIRE_EQUAL(pf.out().size(), 2);
    BOOST_CHECK(any_of(pf.out().begin(), pf.out().end(), [](const boost::any& m ){ string s = boost::any_cast<string>(m); return s.compare("hello")==0;}));
    BOOST_CHECK(any_of(pf.out().begin(), pf.out().end(), [](const boost::any& m ){ string s = boost::any_cast<string>(m); return s.compare("world")==0;}));
    pf.internal();
    BOOST_CHECK( isinf(pf.advance()));
}

BOOST_AUTO_TEST_SUITE_END()

repository: SimulationEverywhere/cdboost

repo_name: SimulationEverywhere/cdboost

gha_license_id: NOASSERTION

extension: cpp


text:
@article{cascalheira_curative_2021,
	title = {Curative kink: {Survivors} of early abuse transform trauma through {BDSM}},
	doi = {10.1080/14681994.2021.1937599},
	abstract = {Bondage/discipline, dominance/submission, and sadism/masochism (BDSM; “kink”) are frequently pathologized as derivatives of abuse. Although the link is unsubstantiated, some kink-identified people who happen to be survivors of trauma may engage in kink, or trauma play, to heal from, cope with, and transform childhood abuse or adolescent maltreatment. The present study sought a thematic model (Braun \& Clarke, Qualitative Research in Psychology, 3(2), 77–101, 2006) of trauma recovery through kink using a critical realist, inductive approach to inquiry. Participants were eligible if they had experienced early abuse, were adults, and practiced kink. Six superordinate themes were generated from semi-structured interviews with 20 participants from five countries: cultural context of healing (e.g. using BDSM norms and previous therapy to reframe kink and trauma), restructuring the self-concept (e.g. strengthening internal characteristics which had been harmed or distorted), liberation through relationship (e.g. learning to be valued by intimate others), reclaiming power (e.g. setting and maintaining personal boundaries), repurposing behaviors (e.g. engaging in aspects of prolonged exposure), and redefining pain (e.g. transcending painful memories through masochism). Notably, participants only reported retraumatizing experiences prior to learning about the structural safeguards of BDSM. Research and clinical implications are discussed by drawing on general models of trauma recovery.},
	journal = {Sexual and Relationship Therapy},
	author = {Cascalheira, C. J. and Ijebor, E. E. and Salkowitz, Y. and Hitter, T. L. and Boyce, A.},
	year = {2021},
	pages = {1--24},
}

license: MIT

repository: CJCascalheira/cjcascalheira

repo_name: CJCascalheira/cjcascalheira

branch_name: refs/heads/main

extension: bib


text:
package lade

import (
	"fmt"
	"time"
)

var _ LogService = new(LogClient)

type LogClient struct {
	client *Client
}

type LogStreamOpts struct {
	Follow bool      `qstring:"follow,omitempty"`
	Since  time.Time `qstring:"since,omitempty"`
	Tail   int       `qstring:"tail,omitempty"`
}

type LogService interface {
	AppStream(appID string, opts *LogStreamOpts, handler LogHandler) error
	AddonStream(addonID string, opts *LogStreamOpts, handler LogHandler) error
	ReleaseStream(release *Release, opts *LogStreamOpts, handler LogHandler) error
}

func (l *LogClient) AppStream(appID string, opts *LogStreamOpts, handler LogHandler) error {
	return l.client.doStream("apps/"+appID+"/logs", opts, handler)
}

func (l *LogClient) AddonStream(addonID string, opts *LogStreamOpts, handler LogHandler) error {
	return l.client.doStream("addons/"+addonID+"/logs", opts, handler)
}

func (l *LogClient) ReleaseStream(release *Release, opts *LogStreamOpts, handler LogHandler) error {
	path := fmt.Sprintf("apps/%d/releases/%d/logs", release.AppID, release.Version)
	return l.client.doStream(path, opts, handler)
}

repository: lade-io/go-lade

repo_name: lade-io/go-lade


text:
package kafka

import (
	"context"
	"log"
	"testing"
	"time"
)

func TestPublisher(t *testing.T) {
	var (
		testTopic   = "hello"
		testBrokers = []string{"127.0.0.1:9092"}
	)

	pub := NewPublisher(testBrokers)
	defer pub.Close()

	log.Println(time.Now())

	data := `{
	"task_id": "97f3a21a-92cd-11eb-b89c-02423cbe895b",
	"product": 3,
	"mac": "582D34006822",
	"version": "1.0.3_0006",
	"timestamp": 1617698123
}`

	for i := 0; i < 1; i++ {
		err := pub.Publish(context.Background(), Event{
			Topic:      testTopic,
			Properties: map[string]string{"traceId": "11"},
			Payload:    []byte(data),
		})
		if err != nil {
			log.Fatal("send message failed", err)
		}
	}

	log.Println(time.Now())
}

repository: lppgo/gobase

repo_name: lppgo/gobase


text:
package appsec

import (
	"context"
	"fmt"
	"net/http"

	validation "github.com/go-ozzo/ozzo-validation/v4"
)

type (
	// The Configuration interface supports creating, retrieving, updating and deleting security configurations.
	Configuration interface {
		// GetConfigurations lists available security configurations.
		//
		// See: https://techdocs.akamai.com/application-security/reference/get-configs
		GetConfigurations(ctx context.Context, params GetConfigurationsRequest) (*GetConfigurationsResponse, error)

		// GetConfiguration retrieves the configuration details.
		//
		// See: https://techdocs.akamai.com/application-security/reference/get-config
		GetConfiguration(ctx context.Context, params GetConfigurationRequest) (*GetConfigurationResponse, error)

		// CreateConfiguration creates a new WAP or KSD security configuration.
		//
		// See: https://techdocs.akamai.com/application-security/reference/post-config
		CreateConfiguration(ctx context.Context, params CreateConfigurationRequest) (*CreateConfigurationResponse, error)

		// UpdateConfiguration updates the name of your security configuration.
		//
		// See: https://techdocs.akamai.com/application-security/reference/put-config
		UpdateConfiguration(ctx context.Context, params UpdateConfigurationRequest) (*UpdateConfigurationResponse, error)

		// RemoveConfiguration deletes the specified security configuration.
		//
		// See: https://techdocs.akamai.com/application-security/reference/delete-config
		RemoveConfiguration(ctx context.Context, params RemoveConfigurationRequest) (*RemoveConfigurationResponse, error)
	}

	// GetConfigurationsRequest is used to list the available security configurations.
	GetConfigurationsRequest struct {
		ConfigID int    `json:"configId"`
		Name     string `json:"-"`
	}

	// GetConfigurationsResponse is returned from a call to GetConfigurations.
	GetConfigurationsResponse struct {
		Configurations []struct {
			Description         string   `json:"description,omitempty"`
			FileType            string   `json:"fileType,omitempty"`
			ID                  int      `json:"id,omitempty"`
			LatestVersion       int      `json:"latestVersion,omitempty"`
			Name                string   `json:"name,omitempty"`
			StagingVersion      int      `json:"stagingVersion,omitempty"`
			TargetProduct       string   `json:"targetProduct,omitempty"`
			ProductionHostnames []string `json:"productionHostnames,omitempty"`
			ProductionVersion   int      `json:"productionVersion,omitempty"`
		} `json:"configurations,omitempty"`
	}

	// GetConfigurationRequest GetConfigurationRequest is used to retrieve information about a specific configuration.
	GetConfigurationRequest struct {
		ConfigID int `json:"configId"`
	}

	// GetConfigurationResponse is returned from a call to GetConfiguration.
	GetConfigurationResponse struct {
		Description         string   `json:"description,omitempty"`
		FileType            string   `json:"fileType,omitempty"`
		ID                  int      `json:"id,omitempty"`
		LatestVersion       int      `json:"latestVersion,omitempty"`
		Name                string   `json:"name,omitempty"`
		StagingVersion      int      `json:"stagingVersion,omitempty"`
		TargetProduct       string   `json:"targetProduct,omitempty"`
		ProductionHostnames []string `json:"productionHostnames,omitempty"`
		ProductionVersion   int      `json:"productionVersion,omitempty"`
	}

	// CreateConfigurationRequest is used to create a new WAP or KSD security configuration.
	CreateConfigurationRequest struct {
		Name        string   `json:"name"`
		Description string   `json:"description"`
		ContractID  string   `json:"contractId"`
		GroupID     int      `json:"groupId"`
		Hostnames   []string `json:"hostnames"`
	}

	// CreateConfigurationResponse is returned from a call to CreateConfiguration.
	CreateConfigurationResponse struct {
		ConfigID    int    `json:"configId"`
		Version     int    `json:"version"`
		Description string `json:"description"`
		Name        string `json:"name"`
	}

	// UpdateConfigurationRequest is used tdo modify the name or description of an existing security configuration.
	UpdateConfigurationRequest struct {
		ConfigID    int    `json:"-"`
		Name        string `json:"name"`
		Description string `json:"description"`
	}

	// UpdateConfigurationResponse  is returned from a call to UpdateConfiguration.
	UpdateConfigurationResponse struct {
		Name        string `json:"name"`
		Description string `json:"description"`
	}

	// RemoveConfigurationRequest is used to remove an existing security configuration.
	RemoveConfigurationRequest struct {
		ConfigID int `json:"configId"`
	}

	// RemoveConfigurationResponse is returned from a call to RemoveConfiguration.
	RemoveConfigurationResponse struct {
		Empty int `json:"-"`
	}
)

// Validate validates a GetConfigurationRequest.
func (v GetConfigurationRequest) Validate() error {
	return validation.Errors{
		"ConfigID": validation.Validate(v.ConfigID, validation.Required),
	}.Filter()
}

// Validate validates a GetConfigurationsRequest.
func (v GetConfigurationsRequest) Validate() error {
	return validation.Errors{
		"ConfigID": validation.Validate(v.ConfigID, validation.Required),
	}.Filter()
}

// Validate validates an UpdateConfigurationRequest.
func (v UpdateConfigurationRequest) Validate() error {
	return validation.Errors{
		"ConfigID": validation.Validate(v.ConfigID, validation.Required),
	}.Filter()
}

// Validate validates a RemoveConfigurationRequest.
func (v RemoveConfigurationRequest) Validate() error {
	return validation.Errors{
		"ConfigID": validation.Validate(v.ConfigID, validation.Required),
	}.Filter()
}

func (p *appsec) GetConfiguration(ctx context.Context, params GetConfigurationRequest) (*GetConfigurationResponse, error) {
	logger := p.Log(ctx)
	logger.Debug("GetConfiguration")

	if err := params.Validate(); err != nil {
		return nil, fmt.Errorf("%w: %s", ErrStructValidation, err.Error())
	}

	var getConfigurationResponse GetConfigurationResponse

	configid := params.ConfigID
	uri := fmt.Sprintf("/appsec/v1/configs/%d", configid)

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, uri, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create GetConfiguration request: %w", err)
	}

	resp, err := p.Exec(req, &getConfigurationResponse)
	if err != nil {
		return nil, fmt.Errorf("get configuration request failed: %w", err)
	}

	if resp.StatusCode != http.StatusOK {
		return nil, p.Error(resp)
	}

	return &getConfigurationResponse, nil

}

func (p *appsec) GetConfigurations(ctx context.Context, _ GetConfigurationsRequest) (*GetConfigurationsResponse, error) {
	logger := p.Log(ctx)
	logger.Debug("GetConfigurations")

	var result GetConfigurationsResponse

	uri := "/appsec/v1/configs"

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, uri, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create GetConfigurations request: %w", err)
	}

	resp, err := p.Exec(req, &result)
	if err != nil {
		return nil, fmt.Errorf("get configurations request failed: %w", err)
	}

	if resp.StatusCode != http.StatusOK {
		return nil, p.Error(resp)
	}

	return &result, nil
}

func (p *appsec) UpdateConfiguration(ctx context.Context, params UpdateConfigurationRequest) (*UpdateConfigurationResponse, error) {
	logger := p.Log(ctx)
	logger.Debug("UpdateConfiguration")

	if err := params.Validate(); err != nil {
		return nil, fmt.Errorf("%w: %s", ErrStructValidation, err.Error())
	}

	uri := fmt.Sprintf(
		"/appsec/v1/configs/%d",
		params.ConfigID,
	)

	req, err := http.NewRequestWithContext(ctx, http.MethodPut, uri, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create UpdateConfiguration request: %w", err)
	}

	var result UpdateConfigurationResponse
	resp, err := p.Exec(req, &result, params)
	if err != nil {
		return nil, fmt.Errorf("update configuration request failed: %w", err)
	}

	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
		return nil, p.Error(resp)
	}

	return &result, nil
}

func (p *appsec) CreateConfiguration(ctx context.Context, params CreateConfigurationRequest) (*CreateConfigurationResponse, error) {
	logger := p.Log(ctx)
	logger.Debug("CreateConfiguration")

	uri :=
		"/appsec/v1/configs"

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, uri, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create CreateConfiguration request: %w", err)
	}

	var result CreateConfigurationResponse
	resp, err := p.Exec(req, &result, params)
	if err != nil {
		return nil, fmt.Errorf("create configuration request failed: %w", err)
	}

	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
		return nil, p.Error(resp)
	}

	return &result, nil
}

func (p *appsec) RemoveConfiguration(ctx context.Context, params RemoveConfigurationRequest) (*RemoveConfigurationResponse, error) {
	logger := p.Log(ctx)
	logger.Debug("RemoveConfiguration")

	if err := params.Validate(); err != nil {
		return nil, fmt.Errorf("%w: %s", ErrStructValidation, err.Error())
	}

	uri := fmt.Sprintf("/appsec/v1/configs/%d", params.ConfigID)
	req, err := http.NewRequestWithContext(ctx, http.MethodDelete, uri, nil)
	if err != nil {
		return nil, fmt.Errorf("failed to create RemoveConfiguration request: %w", err)
	}

	var result RemoveConfigurationResponse
	resp, err := p.Exec(req, &result)
	if err != nil {
		return nil, fmt.Errorf("remove configuration request failed: %w", err)
	}

	if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK {
		return nil, p.Error(resp)
	}

	return &result, nil
}

repository: akamai/AkamaiOPEN-edgegrid-golang

repo_name: akamai/AkamaiOPEN-edgegrid-golang

gha_language: Go


text:
//

//go:generate glslangValidator.exe -V emissive.vert.glsl -o emissive.vert.spv
//go:generate glslangValidator.exe -V -DSKINNED=1 emissive.vert.glsl -o emissive.vert_skin.spv
//go:generate glslangValidator.exe -V emissive.frag.glsl -o emissive.frag.spv
//go:generate packspv -p emissive .
package emissive

import (
	"github.com/go-gl/mathgl/mgl32"
	"github.com/lakal3/vge/vge/vk"
	"github.com/lakal3/vge/vge/vmodel"
	"github.com/lakal3/vge/vge/vscene"
)

const MaxInstances = 200

type EmissiveMaterial struct {
	// Static color used to render mesh
	Color mgl32.Vec4
}

func (e *EmissiveMaterial) SetDescriptor(dsMat *vk.DescriptorSet) {
}

func (e *EmissiveMaterial) Draw(dc *vmodel.DrawContext, mesh vmodel.Mesh, world mgl32.Mat4) {
	rc := dc.Cache
	gp := dc.Pass.Get(rc.Ctx, kEmissivePipeline, func(ctx vk.APIContext) interface{} {
		return e.newPipeline(ctx, dc, false)
	}).(*vk.GraphicsPipeline)
	uc := vscene.GetUniformCache(rc)
	dsWorld := rc.GetPerFrame(kEmissiveWorld, func(ctx vk.APIContext) interface{} {
		ds, sl := uc.Alloc(ctx)
		f := vscene.GetFrame(rc)
		f.CopyTo(sl)
		return ds
	}).(*vk.DescriptorSet)
	uli := rc.GetPerFrame(kEmissiveInstances, func(ctx vk.APIContext) interface{} {
		ds, sl := uc.Alloc(ctx)
		return &emissiveInstances{ds: ds, sl: sl}
	}).(*emissiveInstances)
	copy(uli.sl.Content[uli.count*64:uli.count*64+64], vk.Float32ToBytes(world[:]))
	copy(uli.sl.Content[MaxInstances*64+uli.count*16:MaxInstances*64+uli.count*16+16], vk.Float32ToBytes(e.Color[:]))
	dc.DrawIndexed(gp, mesh.From, mesh.Count).AddInputs(mesh.Model.VertexBuffers(vmodel.MESHKindNormal)...).
		AddDescriptors(dsWorld, uli.ds).SetInstances(uli.count, 1)
	uli.count++
	if uli.count >= 200 {
		rc.SetPerFrame(kEmissiveInstances, nil)
	}
}

func (e *EmissiveMaterial) DrawSkinned(dc *vmodel.DrawContext, mesh vmodel.Mesh, world mgl32.Mat4, aniMatrix []mgl32.Mat4) {
	rc := dc.Cache
	gp := dc.Pass.Get(rc.Ctx, kEmissiveSkinnedPipeline, func(ctx vk.APIContext) interface{} {
		return e.newPipeline(ctx, dc, true)
	}).(*vk.GraphicsPipeline)
	uc := vscene.GetUniformCache(rc)
	dsWorld := rc.GetPerFrame(kEmissiveWorld, func(ctx vk.APIContext) interface{} {
		ds, sl := uc.Alloc(ctx)
		f := vscene.GetFrame(rc)
		f.CopyTo(sl)
		return ds
	}).(*vk.DescriptorSet)
	uli := rc.GetPerFrame(kEmissiveInstances, func(ctx vk.APIContext) interface{} {
		ds, sl := uc.Alloc(ctx)
		return &emissiveInstances{ds: ds, sl: sl}
	}).(*emissiveInstances)
	copy(uli.sl.Content[uli.count*64:uli.count*64+64], vk.Float32ToBytes(world[:]))
	copy(uli.sl.Content[MaxInstances*64+uli.count*16:MaxInstances*64+uli.count*16+16], vk.Float32ToBytes(e.Color[:]))

	dsMesh, slMesh := uc.Alloc(dc.Cache.Ctx)
	copy(slMesh.Content, vscene.Mat4ToBytes(aniMatrix))
	dc.DrawIndexed(gp, mesh.From, mesh.Count).AddInputs(mesh.Model.VertexBuffers(vmodel.MESHKindNormal)...).
		AddDescriptors(dsWorld, uli.ds, dsMesh).SetInstances(uli.count, 1)
	uli.count++
	if uli.count >= 200 {
		rc.SetPerFrame(kEmissiveInstances, nil)
	}
}

func (e *EmissiveMaterial) newPipeline(ctx vk.APIContext, dc *vmodel.DrawContext, skinned bool) *vk.GraphicsPipeline {
	rc := dc.Cache
	gp := vk.NewGraphicsPipeline(ctx, rc.Device)
	if skinned {
		vmodel.AddInput(ctx, gp, vmodel.MESHKindSkinned)
	} else {
		vmodel.AddInput(ctx, gp, vmodel.MESHKindNormal)
	}
	la := vscene.GetUniformLayout(ctx, rc.Device)
	gp.AddLayout(ctx, la)
	gp.AddLayout(ctx, la)
	if skinned {
		gp.AddLayout(ctx, la)
		gp.AddShader(ctx, vk.SHADERStageVertexBit, emissive_vert_skin_spv)
	} else {
		gp.AddShader(ctx, vk.SHADERStageVertexBit, emissive_vert_spv)
	}
	gp.AddShader(ctx, vk.SHADERStageFragmentBit, emissive_frag_spv)
	gp.AddDepth(ctx, true, true)
	gp.Create(ctx, dc.Pass)
	return gp
}

type emissiveInstances struct {
	sl    *vk.Slice
	ds    *vk.DescriptorSet
	count uint32
}

var kEmissivePipeline = vk.NewKey()
var kEmissiveSkinnedPipeline = vk.NewKey()
var kEmissiveWorld = vk.NewKey()
var kEmissiveInstances = vk.NewKey()

repository: mewbak/VGE

repo_name: mewbak/VGE


text:
package proxy

import "github.com/caddyserver/caddy/v2"

var (
	_ = caddy.Provisioner(&Wrapper{})
	_ = caddy.Module(&Wrapper{})
	_ = caddy.ListenerWrapper(&Wrapper{})
)

func init() {
	caddy.RegisterModule(Wrapper{})
}

func (Wrapper) CaddyModule() caddy.ModuleInfo {
	return caddy.ModuleInfo{
		ID:  "caddy.listeners.proxy_protocol",
		New: func() caddy.Module { return new(Wrapper) },
	}
}

repository: uberswe/ingress

repo_name: uberswe/ingress


text:
DESCRIPTION = "Microchip samegame QT demo"
LICENSE = "BSD"
LIC_FILES_CHKSUM = "file://main.cpp;endline=39;md5=8f2a7549bdcd8bed89187e21d29be11f"

PACKAGES = "${PN}-dbg ${PN}"

DEPENDS = "qtbase qtdeclarative"
inherit qmake5

SRC_URI = "https://github.com/linux4sam/samegame/archive/v${PV}.tar.gz;downloadfilename=${PN}-${PV}.tar.gz"

SRC_URI[md5sum] = "39709b52871275bf575cad21ffaf134a"
SRC_URI[sha256sum] = "1488fd156f2c69e6ef4b6d5c0ef3f16526a91769ca7bbbf433f4975c64ea8ba8"

S = "${WORKDIR}/${PN}-${PV}"

inherit pkgconfig

FILES_${PN}-dbg = " \
  /opt/samegame/.debug \
  /opt/samegame/.debug/samegame \
  /usr/* \
  /opt/samegame/samegame.pro \
  /opt/samegame/samegame.qmlproject \
  /opt/samegame/main.cpp \
  /opt/samegame/moc_qmlapplicationviewer.cpp \
"

FILES_${PN} = " \
  /opt/samegame/samegame \
  /opt/samegame/resources/samegame.sh \
  /opt/samegame/qml/* \
  /opt/ApplicationL* \
"

do_install() {
	make INSTALL_ROOT=${D} install
}

repository: kamel-bouhara/meta-atmel

repo_name: kamel-bouhara/meta-atmel

gha_license_id: MIT

extension: bb