C#FY;{Z3o=z5^Wc*$@ope00zm$^SlyvHKWd%?UH
z3L4Wa)86dh*QOO-3>M$ismGLgy(
zRf&8LJp%mK(I$k-F~BBB?4H_%kCQl5zNDY;Jew}Xcc{s
zBbtj)>g8ns50DG6IriK4HIbr`NC$FfAqG{H-H}fig`$bUd#2$AvLHvftJ?-Gu0EFi
zOpQ|wyr$PImxo_bwc${ahC-ifEGjeFy1q%7pKKOm@V{bMoC~G!clFYSQ=uhRv!PU%
zwjH)v+724PRJA?@g@4O5D1RHOdySLLsi;E$X-PDMlE{5t>efd%uUM`7X(O;xyTu)Q
z_gts1h5w6f>$9LN9|dq1{VR@gA3n`a9c8EfHvNQn*{Q?q%5iqZORl^W&h_Jrx;19A
zBz$y)C^XNY*#ZDtf~B3(W857Hg9-|EM(p*1?QX-~Q%@t?Vg)-rO164BTf
z^4}Pp9Eg0Nbf(0fd`I4ozd;5Fq7wBW*0o#ekl3clYYulL5+|xD9V9ww#W~oWh?1`}
z99>DcTf8Q^KJ>~Ockvnx)6=q`h`J6A!-m6d8k`iC2I(vVV3moBjGyJ3W>wqLEt3Sr
z0&+58IJQf7TsVulpr@{AGoQ{ZEYAF5an4UKKr>?Q9Age+!-AQJmOs>~Wz?Gew8$te
z>{@InkQa%9c3gKi9J`>fcLZJ)JN?X>Zfw@7;X&boGc+1@CLoM*uzCJ=$2vu}=V^1#
z0ub^)0|;{!H;~kGU3!)u_0BCF=9iE2%U)*rB%A-!7k~WXFpH0~_`Z6Q9cZ9f&$9H-
zv*(^cdgm@4DNTcWT@9`;nxE0M+i)R@RuY;9S2sYXgZNe`xRZn-`4Ct=Mgix*c}(1D
z126+G{8IpTTfY;v;HibvSgs+wP3_oT$I^q6E7lCjmwW6H#iNXpzzi{B|4@H(FpguTw^6kYM&_B7PEGL5Jdo+R>+)6(c`aB^lOTx*Bl!VnsdiaCz(
z4)tUeR
literal 0
HcmV?d00001
diff --git a/test/types/__pycache__/from_override_stub.cpython-311.pyc b/test/types/__pycache__/from_override_stub.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23c48d943c51b399c13531be2f34f253b1c0257b
GIT binary patch
literal 3940
zcmb7H&2JmW6`x&xilR+gQlds5_CR)Ov6lEDDUKr;Q5DNdRM?_pF>y`D-K;o6bFJkr
zGqaQ|#YT+62cwtv<^at>C$~m)$R$7y{R4bl83HUUV8B4pgKsqK0zpoFv)rXf$pzZc
z^6l)KnfKnj_nUc7e>-$2hM=w5Tjf+YLjM#WehYe?S3MF!4-i2`L?j~XQc;3;K$ok5
zVn7nSpdPG-iXrHSNLUY7BgIHHT8v7lON>VJu4=3plaP#Ph{hg*wC~~9Y{hO8Eyj($
zGDw7!X&zqP
zh4mVpC2Gy0?1czVN_LK1%+H;_pv;}0UszlyEaVrLoVV6AtD?|bYPF_Q1w6H?5z1hF
zd>*`zU!{xzqcE>#0gzwEFdnfqOQ$1v8jpw>*q@Rf8FNQLt2@XorWrSyOw*wGvfy6B
zLPUp>U-5GCoCiXg`h4gPy
zGyWRu4Q7BSLV1a4H4#Qv+$<aSQ_$d>
zWnh{jj6Z(PtS)N?C5jNEs0LAlD234)13-Gf;VE1;Syi>t_)3Ku5Kecm8{i!bK;$)A
z(#jeoV{UvuE1c^XhG+u@2_F6OR5m-E&3>8k_u3Td?x(d2f6NQ4J2;Weof*$gj!)zY
zxrynCNf2@>n*%xmF}X8#Ff^YnF8m(Tnpvvgs;282rzO)M+?QR|46RzP3fWl^dl6RO
z?V4fH8dIdx|8^wh+}
z#F?r8vL7F6m*8qJ3I2$J=O|t@*L*YEk@km6qb|lyT}{n+y^F2hl~!*KdIfL%lNNVx
z=I9q+q+K}x&ZX2$YUYHmtmUh=lkx_LE_txvSlv4sc)4l2Vwh_RhRaLEwdSVU(2GeO
z?lXY;{|w_fZ^0f?ePi1&)>PyVw1r^gQepCw+5>6{Cj@Gonbidm%@RyQEWW!6l#
zl38;z=Xh;>95UvrR-*h(to>u0tc-i96_#d%mofs#Jkx28@LamK?sS*jO)59JX>1I&
zyID9s-8MP{hVo$`chSGYD0$*(V(dv`?57it3wB~`J8^j@aoLVuekJ_sgc-H!%wSRY
z=!i}T7;bd>VBek5;R(wJ5=M)(N6J(rt;)SdrE+vV;*{+Z6f_
zv`z^`-U@W0;f{P;-V7gD1`HA;!L87~*;0qbHcR#-+?Gg~1T|?Z(z#Z^e`CbMU3)NG
zr0=0`BYja6N>Eu+dA`FUGs2+h7n5g}n1czLytg5;O
z83|51pfLiu!=kq=aRA*iWJ#I*e0Jf&>_->QJKYP_n#rv5jG2u6N(d9Na(dfs^lBNW
zTVP4yr3$U8>@8QDrwHnob*lo}0_<(U4~m&id|556)N9QH!i8MORIJ}!=;6;lb{n`|
zVLL+o8FR3V{}o6RrMQ8lu1nIho?-jw;&xAdrzda6^Sg&v*-qwmlDWrHBOnhQeu;p*7UcegMi}+sr@f<3dPjdCkNfQ2
z(e2*Fo!-U!bI%eZPZJYQ5)-@eq&+zHcVZ7rHUcO)3Coi)Se}eEklYnx?|^-aDVYtx
z+dU(xh!a&5Lxqw=abk)BWpEv;J;jMD%2!Z7dLt1lw@OY(H&w!&!H(&!FRAXq(FxaUq6A}oVyWw*Q=%sV
z;=1jZ=-H<4KV(zD6PGhT2ec88B&iXMNWlgYqz6gyyWQgNIqJ1LpIwCQ&gVJ$(0C5B!DOgQp*VYWL^2`|~^fc^maL!f#7}jf3Q+;Jtps0Pg{3e%G5tKZItb
Mz>o6Tz&}LiKl9)(Bme*a
literal 0
HcmV?d00001
diff --git a/test/types/__pycache__/grouping_interval_override_stub.cpython-311.pyc b/test/types/__pycache__/grouping_interval_override_stub.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..182ceffd3994a81dc8f1eb6308d60525e2d5a71a
GIT binary patch
literal 3585
zcmb6bOKcm*b#}S@h@?b{Qfeobor$DMVq}p{)C9JZSWzq6QDTdVr8YGkceCP*q_vj2
z^vqH+RU0t^9gJRj^d$$K92?QWm)?5lu}4Y}AYuUn28tehqhS{aa_XD?FrsV~=y3UV
z_Psany?MWxA38hZ2*zrCYcT?|e~FJ^DE{O{MndR5BB+RnL}WuMO7IRDaye8CNdl)B
zN;zB%!#qqPMx-1qM$55cOhO%k8Z|n~@nT#;GNNG`e*n^cguge62@)$N&E5e-I|mU<
z7Q0ACF?kgcx!85B%Zz#NHE9jq3SC8O63CElq=MBXPGeh%2Qo;6zb`RO)0^GF*Zwz2
z(x@)A>vydR(KPAY>N+4NBcqFmq&5&qAE5LQc@AZ}HP{pSN~;-K4S!jstacXLdYN*{
zbjtBfz=-$A>U+4tEZZtsMi!SXLJe$FZu49`KEJGUTmlqc(>PwDCS{sU30`DY8QaSg
z7b?`8oSnwRDpkwWv^86|Ol&RU;r~zXa6EpoC4HgRlItTahDVldyTZ@r^A@PoD*Bjj
zjm2^{EiGr`@hJdAOnpxEhqn3+56TY6wN>1qWxeM@0%-1S(l4up1
zvS%VZS=s5nT$nn4Nu4@>VR~kIe!4I-=e)6|+si7wrIjlNRl!rMI-v~KAHB$|YDG7f
zrcIErsu_h<$`}ymFKDA6@6U0J`)%DeXg@xS`vYzqu;YNg|D?+a*0_w^W+2o<63R04-;+rM&pc1HURZ
zIxyug;923kvSxcu0)5`6>tD|sfqj0^UCQkI_-F5ZaJe7+c;{r`&Ot_9|Mm~$OIEo8
z{x)r%=cQ#@)_6XMxEe%U4Z^2-krA@+_4u8*$VO}71})j@vSqC}2|^cjQy2T=&qObJ
zBssm1#nzf?!cx_8GeR?XN#t}eLjL5%r!cvXD1t_aiZYRkA*v9013duzk3JJZ#V}x_
zB)p*>wS1i5xi9zLRdF&DMzs46V_gig%>j5}&Z6Ei$r&5&qZ|
z`d=CC5{SGNYR{cJ@@;uD^2#zm5QQjP;RD=Ko5p>X{37ADL?T4drLAcDT2VynIX_De
zi_n3*UC&(>Cor5_Rc_-2>SeTHz@ckf*o!3gPByo=SOV-|NdWUqTq>LthZd;9X`~ak
zKSJ(COBQ7KEgMQY?VfLQ>f|3Lr!P(Z_R@JLF%5l-+2Fa6O@`lIdiC%frS>hr&EhUC63sD!>QsD!?*dzYFK)Qk6eMs|8e9+Q9e
z)_X>_duDcfX6{WrN#*uZ=XO%(8p(A1*vW^a{?@oCq=^HC#NGr0XR{BDqOs(aKBKUq^jP88;ehgsw&*A0G)7yUZ&t#;>GFLAnFlvCA)rP;@atg
z4`IUR0Nic;8p?QG8Gjm1H)SOZ#SP$j2t~R#u6c+g%$stjAO)aB4-hWN($Kr9&ID>p6yn
zq!R+XEyRWBt&$TqERAqy`0%yD!_@FI)`?UrP#=`_3NfzZM#W5o$#v$>v5&oooMXQM
zoap@gj{ut?Ns^jMR8pEqfDDq7cN60G6!p~Gp9aG9_U9=&SAX5pRASQcrYwge&~^_2
zF*N-C=1Tqj&$oxZ*d6+!t_(De9IGq6@ch(>W+3fBL<=;I^m(-X@Fy5z1INWXf<`}h
zIJot0Q%;4ICPv*u&4J9Q{2T#zDL@?!H;0fkvWIdzDEGLtJ~3O*f4PmW?4m1mbmi&5
z(B^nU8U4pQP%ne94gl24Agsg9_)!Tm=~eJt;9kClz%$_C?|V+6$KgpS^f&qA(BH-6
Ezr>}{cmMzZ
literal 0
HcmV?d00001
diff --git a/test/types/__pycache__/interpolation_stub.cpython-311.pyc b/test/types/__pycache__/interpolation_stub.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e1cf8e49b8198ce202c32a2aa100a5b854cc585a
GIT binary patch
literal 3042
zcmbVO&2JmW6`%d!hnAE`k+kecmNJ&yM1*b9v7L*Xrd2IDP+&=MB_s%qV6oa6m1`|`
znVF?%sup4tJ{Y~UHwS1AI=MBXLoNY&=pW$YN)TXT0RsYx9(1z{>CU;VgWUvT#&tjHlw}<<0
zM`x0z2}_Fl52I3OmJIF;9kY{@(I<#x?jw>tCdm_d85M^O_$Ks)(Xx#ezS*FxbrpM7
zjdIE?%JJ905%cuM2e{5$&oy1Uh-)sPHufm@cuCV%suss4uyE7h`1jPI%2j}I!vjRR-Mie
zqwZ1mTx?HK4u%(&X6J6`vvb$y7w1>zmll_U6HUvj>hz9LtJ_qEOl??%GSDBKcR;i5
z+Tlm9T;JUJgNE^>XL&ZA#8>fTL_T?52o0yTv?heNuviS7vy6s}$*HpG*6OYUS>$DI
zR%y-P<%o#|>Q!Ab33^-S{}1)$IyFOO{FSz)i3GT-x2fsrRo7h)QiQHqjwSYwKNs+S
zECmHfoZHkL2ugSBLS)$76lv@arT6giH}LQfQ3SPzDl(BO3RQ`GA3Xy8_q|03Rbs$R
zkl20o7(Y(pfY@X(9Qoj7ud%v05n>EJ*eX2y(BOHs>NF{ByHhb!)WD8V;0Kx#_a?ax*O23-#6oDAo%N}5ym!r{$#Fgr;AZ3Q%sNd$UvpF6~v&ekuh`0oi@^K*d(0}46
zJM}bkZZC80AB88ge&*b6=H`Cprk}j|Qsgy=GwL;%!;D>m#PK54yo}hcSpo2L@g^dWl
zDpm&RRl{6w)Vnppg<)um>}06eLtww~HqS&n9tCNC$z{;ve+AM7D()a@;4|r2Zrq<(
z+|4cR=a&5RQah9T^EZF`W;cWPGx&kp&g45NHn1f9du-xa_UzN_#l7ss-R!0P?4>8e
z9YsDp^a25SCCGytoj5Asr}^o<{PYjxNx{!g@8%cx^NSB=pJkvfF7IV7x6@gF?EK$}
zKYF>NpzIY;&uXBa)jCKX(AYZ=-(pc_qcDeMQcMI%U3ZKc)%8HrbvT6^aM{aK78_O8tIT>NT-a_-BNdtfRd&%ooE#c|wqPg$0G)F@u=x8iWU<
zk>w(l)b7DCh&Sqhc*+VwGt7|4&g-oGocySp`j6Qa5QzTFuL12Sk|cH1grs(mAUPzZ
z@1?}=0OkGY)kfHlUI*x7|7}-CjZ5Qg^;1839gMyA?Ju{tcE>*4AN$Z(Pqj~u`Dy{K
zpW2BW;8_}fP1+|WPWK0A;{9floYC?X2fV>jKN28rn
zNE&;J&g`Kx+rRQJUGpbrchTHFn)A`z!N@y*G5ygiPd@NR7IsG#_D2@rgFEpN383*N
ec_DbO-Xh>RNalC>i|B{gjHLW1f290VJp31{crXe8
literal 0
HcmV?d00001
diff --git a/test/types/__pycache__/queries_list_response_stub.cpython-311.pyc b/test/types/__pycache__/queries_list_response_stub.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..975eef87582e81878e1b7b5701aff31fb48629ea
GIT binary patch
literal 4300
zcmb7H&2JmW6`x%$KSa?YEh%+k`D0AGwwTyt0vkarq-oU1PSxtesf4tlkuFv{Lu;-5
zpl61bsoJnn_+a$XqYJbL9SYY*bjT$@4*3IeqznNj7BFC-=)pG{c7Y(LzS&(;B+a_@
za`|@l&CHwMysvrtk3DcD~G<^@GeFgvUDi4!XIpdBW
zMRd&LWR8s>Nh3_%I5
zFwenamEy%Jb*C@PV&a)Khq}TLmgi!xf=|5Ox+l`K(Ze(_?sYRfsB|DwRA~
z(x_UeA~YT=3Tmzv(&-rwyPm+5SR%k?+6L#?G2EJA+x24lsnqpCLGfe1S~?Gp;pKXj
zP7|XlD0?c+Q&9cA^NTa*=Jc6!=VupYmuD9jmi#x?EwQT8Ylc&`sScXDY7xp{{+QG$
zXmHNr;y096J(ttv^TydYLVrkOoM-e(&0>_~@f5y@^SW)hYdn7v=S{EX3fZtN#|j!=
zrNU{@imZ~yU!IgQ1VEJY^WMs3YQhM~1PoQm1S~DP`FH%m^pgdNVGZ+A-x
z!Gw-zgE6BXNDlaxpiYa%BWm{Cz`m4;o
zEJr}@3_|_&v4+!Mg|y@CG7ncQ8?sm*$SC7<>+{ut-0}2ZPS4E+*(wZWpn><~4Fbs(
z0?M#2^yDDHYBWeq{eCOMMp_>n*EJllzI0zmTqm*2sxl^IZ;%-Q{Ef6s%VDb1S3Pgd
zAMWy&r}9vKp!nmE&b@Wr1@q`$kO>T%n=-k#uUOQ0{xLM}B8s3QKxLIELz|D^XxrP3nK)H7wWlulMo^HN%@cv9IhH__~AvKqNAxR6VL+R&I
z?S3N6s4N99J;sBRJv81p=%d$oJS*B>2ZKmo757KwI@;`1fH0tQ^?KY5<+{RuE|Q&Y
zBqWIF+LY_RboELg>Q=1RS#GG;)y>39(||!VqHV?dMk_rlb|Kl7a9tq@qFKsTvUjeG
zm5oB=mII8_=c60Nd0A{iiB{tRuh7tYZ5y(L@Nj5E92RjwAhBV9z~CzYEi+j^`&oIU
z=vNKfB0=2=&YCnmI7+Vx2-;jw$}Q>BpHI)uP5)x?e}1$&r3$#W2@u)i8{>6c6E?D8?_}{E
zt(hHbq4?0E@~??Qk8^K7%Dw+E_x^V7gPq(5-(P9P)B_{n`3FY8^AC*NnQJA`IDRxX
z`EYFVYx4bgV{CGJY++|?;m*wCY~fM%?8EHYW+vB|IC-Bm_Meu4Gu0P3>@C2zP*B-^
zcm{z}Nct&Vmq}mO{j{#bheZwQXWh@}`W2|iqn@O$!?y#lhXYGH6m&{LtaR_E0&tfRC_x8n*k%4wg-6Ol&q|@JK1YO~J
za;d^NE65d(0`X&)c_nn0RJBeFS6C*~WJfak9$_-Xn2Z`u
z!KU`RM(_RP$jQx##;K3Dk4*0znQmx@n)@ai+Bn=lG?Sy?-O9mT(%g3-?CYjKz$GCc
zl+Oe@{_f`T-^(qv7}r|ASJ2+$Ekk+lxcUqMc_B#y&Dx2
z+h~3V%{S2elS4=TVm7to-+l(6aTq27fzUV%6DL~fHx+Q2m&r59doiGckAhnNHuf(1
QIzFw$zEMAneJ30L0YTcLmH+?%
literal 0
HcmV?d00001
diff --git a/test/types/__pycache__/query_definition_stub.cpython-311.pyc b/test/types/__pycache__/query_definition_stub.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8f5314ff7ee23e446a116142354600b6b3a256ee
GIT binary patch
literal 3063
zcmb6bOKcm*b@s!LmXt`5vK-l_J(2B1N-VNT>;e&jv})y#3P(&LB|&Hui`CAkT5GvW
z&kQ9~wGpH6!RVz&2WSpD6mE>@kV}CcdasWwL4b(`3KWgl|(gJNh)YSQWNe#)uQW1?&;{j;<4&L^tq)4)o_C`)4I(P=L
zbY+MPRMKA}qE?2k4SC7-ysoUHo7$IXT>%}+^-Ncq7&N(+dZ2AamC@-1{7YmIQ|p$D6<45c$xWCELJEk
z*Qhu1@f;?;U9VD4Si@VXtf0^Ak4de2@_NB(Y-VV}dcw$9}8lNted@yO%oT-jC
zJ}U}puS^=otdBikU`iYj`DVKo=eTNlb<1@dMdPWA_57p~YJXU`1XF6UQKK`&stL-T
z%Hx?-!{Lw0vlp+LvllPT&Ce~)mFE}2BkPV>G3iaKT63uhky>*IWgwr4VmeEg9nX>5
zUc9vN;Lire!B`dPALY6=#)la_r0gY
zGoqVTz(o3*;a`+nXmh`j0>l33O{v?;ErtI^z=hErLORhIo6`PEqgMk_x3u1@xUJq&
zH{&mf0fOj6--`8dD?Jtud2*oPmO|o0ca*I}udFPFjkBHn>pPFWMBFHTB>OdVxjGkk
ziMCVJb)iKIAGgm9xBFmJEi47*SsK71lUGof;j2!~T(evUx(n1eq-DbPJwa~@sK{*8
z4HwLr&u8YY&iwA`#V|Do-HC~djQNbcCY8zK3P=0g>~z&IC6mf*_c3-PGT5;NowOlV
zz@WxPC0>`DVS353SL?NQv2dvxx+6Op33jruTZ9{@`)tZ~(M{DZ(|aJv{|=y?uDFGi
zfsd6Zxk7Mqemhs*&6R_6xtYoR?W@0jwVlDc8GKJ~X7Vi*8z?LPKYsEFWO(-7o$R~Y
z+4H;E^N-$XY3hlgX9&Ox3GQ8O#nA|UoS)dqPkc`vjRg6L?fm?1e*WI)8UM$;E)!1hWI0f*ThT_9_uXRvKShUo^7i3kf^67)7GO(L
z6s4sn6upHc$RQR~F7%ep!la3F+(K?cP
zU44cCypSM3h1P3GIr$i!*+FMEtHFg!!P(2(=*lj-5}+%4V<*1O2Zib2lTU-Oh3&D0
r-LZuLjke;W3S`L3;F-j|cm;vyAe!Ige}%q}%_!Qx)DN`($d8`^nKC!(
literal 0
HcmV?d00001
diff --git a/test/types/__pycache__/query_entity_input_stub.cpython-311.pyc b/test/types/__pycache__/query_entity_input_stub.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e6b1a2c6d21b870231e8eb521ee55387c210d769
GIT binary patch
literal 3451
zcmb6bOK%&;d3N~}Ntx8ck4CmUrCeEzEz+r*q>uwQYAvTS6v?S%387IeRy(6`t>rE~
zGn7nKMvTG-qn92XAU)_%xG|zbE(Ln%56E#P2#~OV0Rcr1zR|D?1UdDaAt{NpdgyTZ
z&CWO9Yrfa)-@3aK2*!%Pxir;<(7)uOHNwr8*S#7-PZ2>yL^Ps1T2X^J-#R$AdNYsgzW5rlGUW{v~OYX*;u5zN7(2$O3geIPWv~S_x7{w%s7gKKk5Te}|
z5K9$Lkgj6tb42vwiMuD2Z``+O3cvAMo(*X
zbS5bpv$b~p%Bm2}knYVB9ddeg^aA$B1M)cKV1ui*h|CoCz(MHOH*sIKw#;~x<
zlv8F?j_(6T&Lb=D;R^GFXL(KzmpwuqEGQQ|pGeG=Y>q8J;Z>94FQ`kIDJa29%qwG2
zqIjl4-SOL#n0QvTOkH6L+jFtEgfISodM_ptpBzYEtR2X0B0YvjNVnYxX8g$+=pEjuW#Y
zD0?ZxlhcEqPiJmSOc^&OZca{5&P~ot&ju$~ZBa7l1G8Llr~#f@u?c0spHV)YaD^>u
zlWwId=5Cs&K+Yc$7-t#1U$q$}Sv-dC;;d_yY4$SCN~hPd`1hA3jR5^}KkF^tqn5}j
zBq*p*CLl6$OUeRD#eT4qthR6(yvhjNkgtf33g&{@?iWh1l0zuBm|c-UQi`X+EEz2s
zN-jLGSEWS_6S`!(wxr8vmDGpQI1pW?!aOwW7)vApF@dPTaMYS3$2``WJCK>U#gCUD
z=+Z9bvj1&R)1xg{fxZijE~(QE6)dk@@m$DDUf@=VmQ7wz{u)*BYMu-ZrcReN38W4j
z*>rBV1wpVXRk7)GpOS**X|eFI#V8a9HjlITVL~Qc!vRLg^Ol3;p^N!T*>0X|K|ds_
zw`#axvf-&HnGUyP+O|fh`SSW>czKE_f?kJ;I?;+D8YcQ<^bGLdHi-}_MgSWlk;mZ<
ze3V3?L&SrA<&GmcJS(b;Yd`J8;wmJA>I#r1)kU7S4jLrrl8smz_IeD!QzQVk#>P>)
z7E(4{ZBuV=T3}9S?d)$_J|wm!lrC($T$rv!^K;MjAXVkm0MD6KNASj~S(zNF_l!yg
z1L6%OY1pzRjU{uLvLN2-T@Z$l@y?}^xTtt7=*3rhnB?bfsqdm1AYU>*Rm53c|BO#4wjt!~*tl@Lx*Z@JoB)l2vpw`+n9M0!lNZ
zuA*6Ee13d#YW&wz6G3tkx)~D_jCqWmk-}uWg43OLHt)0`DHF?RG(L7xX>2Nkd#ol(
zpfSWwNqksR2B}5UTCP?aCBvm`Xw&SpVr(X2s~FcVbSj;dN!>y9F|hKl0W?w;*OAtB
zTYJ%a&L5oK>Ydr?o$*sMd+FXkfBB~`x6*hgjh}?~(tULl>6+30Juvtpb8$Cwbvtu)
zEA#$N=Kb%->mmK@iB|}~8ws9F)uX5%@Ai#s_lr&2I!L!?+LM63v~MVZc`pppz=baBr17(g@4XK-6=jBrEqZ`9Y|_FX4sH19)`s
z+Y4Xv!E(lo6ej%ndKlAsr9sYglq+edwV`?H6z-~Q~Q>;7?1Jsj1}?S+5mw?F%X
zxv!S}cgMB{uk8$8^TPvsrw9CSKRiF|#d;yNwR4AH@ATQm-ck4i3~BN?IY-gZ=*ES=
zzFXH%M#A;WsAsrdI5VWbLIB=K;G^^PpCb+LqTy{c{7tw2;cxwmlUwN44!Y%|Tl)ip
zUtRUjU-$3K`vVJG0}DF?3qCqikDk&XP2L8tB<{^I8@w0X`Io*c=)1_c7W%vXQRtuY
F<-hUes%!uN
literal 0
HcmV?d00001
diff --git a/test/types/__pycache__/query_input_stub.cpython-311.pyc b/test/types/__pycache__/query_input_stub.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d9478c21682b96b9876b491201de5263b1dc1428
GIT binary patch
literal 4608
zcmbVPO>7j&6|V02^^9TsGXyWjxME<}li(SzvWgT$*m(KVtiUE~FBSuX1DD)#$Z?Ntbr&sGt%4p~fEC
zv(ejn+I=P6G-WDL`_iiz?IHU%_wUiur=kmptHV2?S-oND4gA|W
zWsQ^AHLH|UW>StH$TKR=D3dGSOr{l2(_?Fxyy^0%*>L>u>mZ+s&l+ZZOU|)
z61>2iDt4DBo~luM;&K@i$Ea7S?dq=S*w|UXAH1F24>FkxZSC`ow%(BGFg&{Cx;1{X
zRC2(iUNgr+ZyZ*1sj*bZWX?L+c3ez}=}O-WOXnO{b-S)xR->4CCSpBVQ2f}Z)92xm
zooUqQ1kr0QWzR%<3aa0GY3l5`i`v<9=gX7jnex=+w0~gLbeA-GORv@}szIb~nuIct
z&&ZgT?ONTPIj{daiO`oBj7MD1I)YE)5oi7eHQbRCf(c?Z%3O%I7!vb<$tZW~%#gDK
zmJl~xE08}+7xcR2;?G*sgeEE2Ho;wH+KbYJ93Ye%%&dtdNEccvT9)tvL{j7}#DHnb
zCjo^X$#^{24<)bCTsn#4D
zz{pG7SfW*(m%=z`6T74%Z)@5Bf|_H!tKxD*KB9Vo(UrGw^#XJ1HAt!^UAn1T(X@z_
z_ZHe_V7+UzrcInx?Yt0;xK_7a(|Sj3pG(<@x>afCE%XJBMSX&0Vmf5kGKm21aya@b
z;zYO>Df{1RVMf5-T%)2oi6tOPAr4%|unz2cb)GUYI43eThwHWpH4snPZHa4A#4>IA
zMY|e7;p4?sS!0W)Q#x9L(o~Y`sr0c)ek~-%gv3~<0u(T>QNvs?DdT$Ys;-D<
zmncLOigD{r$qB4O^zB89ViMN1*U4hoZ=hH>(7JUwvMac(P6e(<_6A$-Ga_szKvL|lqKfM{++lT4)NoBB*wGus>-Kefno_J=
z+`-oXj$(7>|2JX@2wG
zK4jdX@5q7U#kt{A0be}<3
zD1RMm?-(b`GTYFZfM`iHekD-^cu>SbU&Mt>BoAT0AFGN87B%^Mf*(?nYk+dX$A=8qFcaElo
z=iC;0U=rEWGyhJxjW*i-HcV(AQRJ*Ew-x@en`#duS2z(K8^Zo8M^pn*H)By4tgE-x
zjpQq0z#wrF-%RY8twb#D@}#5TwnCC5ZYrCpsI0*J8V&*1NyQ$}trahcjvo5pI#ld=
z8o<%Apow=K9Ha~fow8gREDM%dH;@@7K2rP~Up8wR^dTlx1}Hv&!<6B`W_!zpHP<8i
zO8M8|k$()2KN&vtc=*)T
z@agU0)86M-yusP6!P)J>*?Sjv`iGzNk3Q}neMG*?d;OzZ{gd1MllRVkpTkdbYy^c$MvGw~dPI<6
zAs?f+3_oExI^q6+kPRn`Fj6Z7pr5SQ0N|A6g`AAe&&8d{g^bvb=~F@2PqUAJC(1BC
z540Im6r~wYDe)!}qz@_Gce3L56!m-2a|dBBdOk&`z1N-1cv2bKiJ$YL=hK0sUuQQy
z-5Mxu50t$4ft`bcUOW%y4?C$o0I@REAv*^T2V=YG4{!*Nhr~6B4!{5PN8g-ms=rLc
zo3?^_-*2uczdEcwM?hW*;-P`2t03jQCusOF8r~T4#wR@d$rd`Zjm~)J%+vhAKc4Xh
z#{a(J<;z?7@^-%Lq26XPuK+S$CC>%#l%s-BAdP2Bt!O-2fP
literal 0
HcmV?d00001
diff --git a/test/types/__pycache__/query_response_stub.cpython-311.pyc b/test/types/__pycache__/query_response_stub.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ae0f381e701500296c7db233470642f80e0be886
GIT binary patch
literal 3813
zcmb7G&2JmW6`x&xilR(PVxrWt>?!5O5-O2yob=!ZY1K+{sVPFESgbfBYpvxj
zJu|dS)k2KI2cwtv<^at>m%1^cLoNk!$RFV2N)TXS0Rsk#9(u|ab6T{Jio+DcP3lK``*CQWWkQ(~gaP?3K8Fp%$DxJAB?wyf+=+5gBtubhE0Df#@4iK;@mJn&B7tpnxlEoj?n6d7<8-DLG`uH>1`X6e34w{C$
zX*f_whO6Lg+PorLNP9rFtMTGjaJ!Evf_(>-b)uCcG)nZl=mGG*P)j5!$AFt4vAfYO
zew@UiTPOW~Rc-BlvMlPWTc<-TT!#u#y%`W&U*(0$(KZG8<#s4tdT|lReI$Uk$4=+E
zHdAhW+O8hnI>3?0)~Vkx3T+Y(+
z<`gas$bxE+tc7nV)R$9uWLU#pYc4gulI2Tz9Lq$m$O4EyYcjZ4@`vjx||pOhQrI
zv?`Rpj@3QK$;PBK42=>*i*g4m%JSpIE_Y<;3blscTTx$WT<5N{H4+N6jD4YF`ZBo6
zM}XWx|Ba*U*~giQ{mjHyXCJM2nTfs3(m`g)OD?^Tk@e$@iaK*x5?(_2i2+09CkJ01
z&JWLsHke=$={f@ZS-XvPj*bto;An(_w5{FN_%B7`Xc`IWL~HCw`>%|!2BPmq!g$!$
zZ|ghpSHyrpq9nQ->sqaaEOvNutl_ps;v{NmyNR%@EP<`j7V<*b=mOwYVL_fzU}vv$
zfmdk&P1}YF7cLI6hJ(FdRSD|_<17tig~?-=pWz!;&A4gW7VJaNS^$uVit7k^OF$K7
z)d^tPnEGgHZhq?5^D}<$9Bijd%rNFM_Lfv8ljY|^PPWbwey@a+5p28c4P~xn3C<1;
zu@2@U>`lp!%9Vb4)vRpPYeA84sTg`D8&ZNT1hz|W>&GFBogi&5DS;gSJCFdVxQVo$
zE83HR5%2Wk-azSKpyZ`Xhna!De)5-3_A>Y&gYQKTGlNYO>nUmf89x04u$?`>pFO{q
zedi$i&ZGWjL_c-nIRf%hl6&*bILhJ2gJb)HV_%X-Id5=mZ*cKoaPi*slg#Mj%!U2T
zg~N2#8=m-_cqcD3BPjbWh-XtEo=r88-jiZK0{<4rb#@Z&s!YZce$p^xlQs-LWf*V<
zt;12v@Y9BI0}gMknS^1$F%#ImD!Z`TuDc{i$WK7kL!>mT*fDtmSL6~r@Q;ApIr<$&
z$Gqs+(^$5t>#=1GoC5khg5v#mueMl8cxmc=G4Qxejux~TYAP@(t&Qi{xHLKn#E)F(
zYXM4G1|4KPnxPKv4+{Zu~5jHtMMn|wbA{s-(`;K>%v
zXMr{&nx-|Q2`$=0k_;d%eWzFco}xi7d>ta}g|DaR1MhWLGaA=M4x_*G!q?N`w?F;G
z&i3B$dk4esdC|8Hhlagq4z6zw69a%~ZRD674xI|-I_Wnsq{k!j9!F=!KP8`CZ|Y}b
z(dK0h^}pR*(9WIFpCceICGpU3^NNPFQ;$)8ALVxzybIIb=*%9PJwUS_nteKS@^9Q5
z{`sR1y`j?HQ0ZW(${{Xqo
B3JU-L
literal 0
HcmV?d00001
diff --git a/test/types/__pycache__/query_result_stub.cpython-311.pyc b/test/types/__pycache__/query_result_stub.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7296450c6289f4bb978ed2a96f733299b0202217
GIT binary patch
literal 3960
zcmb7H&2JP(7O(F4^o(Kbu^nQJaWN3^5InQa=7f^44mPX<*v{GkGO%hlU1g?mPxnyO
zV|%=ypcMzSm)%1oa>&6ac2RuDWu-mrAHcDVyuxZJ64Gi9+y=o)QBM1+x@SCN*wv=p
z^Sb+0y^nhDSMQboyl-C$!L{OTE*(lE^iT28yrSXDtE__1Lqt#s5rwFhQc~aByPnkiBh7HEF~4xB}NlgS0z$MpKVK+jsB_u2PyLOWk(=
zQAGD0L#(^BpLCVFzeGeW?Z39)P6p3aWfiSOzC^1E=umEDn$jdilbh*BDrkgXsIiCk
zZ1gt2+MlGGCQPN%zVs?Wd&s`c{d@FeRdgPa%zZ?9_Kfrqbspt=byyR+qSr0Gjz6za
zRzHnhvqCv#Cgu1xaKv+TWgJ(T<2r_8<#EL!)WR<1E-$1~3uTjI16X)f=lCYIDbrm_
z@Dg(>*ez2$Tc!5I+%zVRQL9kf)m_uEv9p9v{5-oSQmOMT?KkQzy&=7QlMc2W7gJ)o(l^7>ImZ>Qy>H^r}nQ3z43@>i1rnot(O;O-`Mgo|#^lo}HQZ2UbnDtkE^SQnjcCkyjNY!9jFKEajj!Px(Oo@v3g;m3T)#=Vco(s+=kRY&iTN(L
zA?D_s8@H(8<|GsBR4H>IL1IYgg_%-S>r;rDt`*3F8&${V6i9fF9#rfJ`_C|)$}YRz55
zLNZ^tZeO>-PT&;)lF=#y6x#xcx?wnsfE0EesdbT28}hS=u_IT;_n2$iT0A>@X>Q`|
zf_7zoF<;mXis{lyTg+wLk1@I=BXqQAI2DL9*ycrUlxaoh#b)R=5qb?mp9=$jS3d6s
zd1&UmnM}yb|5hu}H8w2*5h!dbY60o(NVpW@4C^+*S9E4WaQ+W4{QPxG2dCDkQ4!!7@o{dXnHCnQ2HA0m5K!>u!zF|DIW}A%d5>n-ZlaC=FWKahClw_-@)Vn*4=mRF4(E
zA4;6Fs@VWdEm*Q{aYGcm<`oHFUi}JQ9wLgMOQMoWlv0F7iFzMB0{(a5B!o&a;3i1y
zesm8%PU6s8l72>}AFvM_ciyetSU=Rpz%}qsb`i{Bj2DbnLj?<>aSL}|od)s{xj>uO
zM*F-bQ#5I1Q|)YW;6!Bo&{;;IAwl6Frr}Cku-&<<+XgKxJXZbg8mC$_*TGkqRu0uZ
zE7PYz%3u-NlDwemhE7ZhhSRZN&v50x0ZSdFNCLacJ
z5B)oidUDS)C!c0c{w@0CLoai3D>Jv9ne&o!uS87!IHLeQn-_
zx)Fav3>YLzqMNZjvy~2uZJz9ExTBCbiJHo0qEl7?fBi^^xwc&F0p5Dyk~l@d*`o%f
z2HK*8q-8<7f@%}w3s6!EfdNg6it9)!f>G9t+}xC
zdgK{pUYoc)F@163(~DDndK#J%bEg<{7<*SJ6RGmEZ7zoA96v39qy?>u4M=059XQ+6
z-7*-9uy+JMDrWlKH*{mURt+`>7iys+vI9~uL|=2mt&g77cl1#x1zYOGF
z>u)D|+>0K69_wkSYV30boC5kXg5tgRuZ656d^FT_3_Na<)`TWQ4h1HKwR}Iz3!_JY
z_>o(DDS$?@S|_^gng)xCfkb$yW?~yLu_yfZgYs5r)~~|tplB83e+XQD*2B^%!^NUZNOrBk2j{3_lDJ%2*_(eJT%z2s37IwGlZWayfNmDf9f4MyM-pV(WHkapAWqI
zr+IJigD1V-z=f@W3)=%1Jd|z3`xU^(o8+b7y?)C8&q6%E?fV7#J~p95{;GZy`MY@e
E4|nuJGynhq
literal 0
HcmV?d00001
diff --git a/test/types/__pycache__/render1_stub.cpython-311.pyc b/test/types/__pycache__/render1_stub.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1976d1be2574eab887480f6c26e03129e3fae4e8
GIT binary patch
literal 2950
zcmb6bOKcm*b@s!LNLnkBQe;<_HIP$9Y$LKpdx_&ZR{aUo%90zg4nntBtae7#TFYH}
zW+|Df-3WybMtf+`i*rZ;o!lDH!I$28$g#(zKtRF*0R$91_(sDi5aiT1yGuz_T%aB9
zzL|M%-e=!$_?J_sG6=@Hzq67|A@onN=?yhryedctJwXK35Rr&%OEn2*#g^+zO_2mn
zwbgo}mVkAFB<*B9RZG>=wX}o=1T|$3)HAh=gk(e$H1iaseGYFlYFU!5<(%R3h@N^A
zv0QDC4AgQTAtKiX?+iNWXx@-E(0%12v>|~E>8{q}CK;OE$v%}qBD}H0Av(03@9mDy
zBu7)0)UQ9ZN})sK)Xv}uIRzQLkBIgNk)acmB9WI+DR00xp%0CgZM5*uo0PRKV$Z5m
zPMJkHz6TgFPp@CV4d!~T>Dnb+cL}wzN4dw#nM`%n;@AWf-Y_`+HFYR6JWB8ibL-e!
zrFgMHo!MJ+n7C%MP94wiEZ4#A3V!SV)B9E?^Zudq<<_Cx80j)Rz3O=lez8(Fdp{IcVJU)a_EdkgRNjy?d
z;FBZ?8JP~UvCo#g=JMw0c!Qf@SD15{1D==7!}0^kqRfREuPy?3f;@n|v3>kp4=GAo
z+L8N90+cJ8XRk5}>5C0aEYk~hVaws3;h3~seI^IFCZ{_1$!OXhk9Kj~IpoG53*)U{
z&{vE#%7S#S9>CR#X>%^D!Qb4gth#ktVND0BrLy6&waP|VgENiR4AkDbWm5h+)JYmA
zYcp|?0&7LoWW|G&<(0^g3%c-DxzP%;X82+HUG6%YqsLraK1L{mb$lGa7W#J*4V~N5
zrgpWd=hwdQd~K?&&3CkUKRy3SxG_jF>NT0e(y-|ZMgkCFFoxk{`-8zXua_-wh@9wS
zzmp!I?ZX}j2M$MnraY7$Nc=qydVOzr!iacm3;o|3{St`0qx1*=q5MGJPJW9G5JV;F
zPU6IAsZZlEOO7NwkVulKmb8=V=M_1=IUc83FS|vQj`D1?EGpZE#?<5zGgM_b;Gtu*lk58GF```_dO`Ep|F81>9e|gRDp%J!(R1BvcgZfTq{-R$Zs0ur~x=6(@t-
zvSF?@8&NHAAre{}8x0xbtn1a*=GbdevPb+OaPU6>h|&^wku-2i`m!+YpIc}b7CVJS
zKexEA75@0~?>}y9xTE36>b_R&B4uDv`q$XGKmT@b;+@@zciI#0b|&8SKUng|s_n6A
zXRP{oe!n=eSDfB0PCqCA81{?P?czeGxbXPem)iKAHnXeE{FV4WUhr>K{Y$^_wVAed
zyQAIq)3@0fuxFtpv+uwh7C|W$q;=gf>QvW*jIP5q*@W9b4|2MG5AK(klG1g!2?3oA
zBUq>4HxfDhyCCWr3MGeLV&YFi2)+*s{!0K`hrfMw(pM)B5<^{CPTZ8bNWhm0O6DKk
ziBW0Tbmf7>hd@1ohi8sZ5jj#Ube4u$NvJ*#AW-h|l_($5jTSK+&oY@R2&wp*Wuk7F
zD1u-rYGdVIpDM@AsT}@i;AIwFhoQe17HsDPm=L@Qy>A8y+cgLeMxukzM?=Oq=YnLj
z0SQgnuwV+EBOG(&uy4|rBClU&KLUbiw)|%RyNV=9T{R`CT_ivONx7}8_#L34-~a3*
z?Dszh=(7L1r>iEV@qP8O-~Swp;7{&skG4ljosrVk!v5%(uMWfW^?s@VnJbMSf&J05
z5$!nq8ip`@GU{Y2BZ>
z?2o_KMpruMijS@wW(1X1d+P6v$0iP3`aJ&4
zo8R~RzTW(;w^u>1*4)kIzef@JH-Bg^IoP~T2?#ww1eFjGh-e5U0q&9^R-}?7aGY$&
zl~5@J`w$5m;Yy?wsYFXr0rhZd#OSFgB}G6Yq9Lk01#RELzqLv+5-r8efm4X~jv*E=
z^^u-Z{1zf&sc*5*jJED|p^olJw@_UG9m3s2Tbd{|x*2;af=2iU8k01+(cgYLcqefh
z(S>gNzE=`WlHSd}LwZsox`s&N5hBS$lr#|wDATXOJE5Ce!_XS|(;8)sN$ltqYE!0D
z8-D>9eji^ukE_gbtg>ZfaK$3jzz($?JF6(g72U>VK;gP(<2%%(Omir~%gm}^XNBT?
zm73Ex<}k6!wF)&I&Cx9rTg&*&|7Z7%qFn1}Uutyp21twH@fF9Z+LO7Q1tztsJ`s3h
zv8+SOD;Y(Zv9M`5m=fLbeJdN9ZR3h&)-=OtWR;gZ)(aWIlYU*e3b$CXQKi#Ft2&gu
zyk3dW<3?ih3wPvX%Q4{kGMM?doEVA&_z4%5v$Eu>}A{4&QbVy>i1&0Hb>
zv!9-WL_y9hf_(vCsA>*4Z~Cf!e`9>{+{DjspS_it3U>3I-ObK!26n}OKHI^*C!
zkS;B2u{$~blmmX1zv!u%K)}x6Ws6lbrxiJ{*Lw6#wW87XFG!J3xlz0@d;Ze=D8%sr
zzO6h^c)qQryR_`6E0(qD#Ry&2O`ZE>zvSKiOz;MvPOQ3WLLyYle<97V%e-pZOA0ox
ze*v2(h$0v@s3a1hBvF}&kI+-Ve;Y6%R0;t$LPC$^L-;TWLxV=WRCfs#oZ8a*2i-Va
z126rC#5R!aY`HU=zz&~*+^N@-0G=QRV0GbL=qV1sp36RQ$
zZF8^i4~^W4RiQanGhw9U>K0qg)%`&=QEg1XfLhbb)P5i8FwG{b6Tu_{(HtLKIbNtB
ze8?dly==AN#mfGRs&{S6Tp#HUHcvqI0R1Q6tUV0iA^L9^B|qFvWVaL9f6hF2+(dRO
zQQS!s-DvSOkFFPH)TuF(!7+upaufoDpQ8bI_wF3o38!6Bz(fws{yz%$(MIRo0EW)$
zE~f{=eZih`A{{bvxD&zJ;P&5H-5Q9vDRtMx1M$AN5q?Ju5JV>OX6O*N&}H#}CvP>}
z7f6`My097PmgSAGJ{DA8cRCJL;d*wSpH48-Yqo=zXsbRA0}dp|!mYI7*3|b~g~h-+
zivuV!e&Biu8wQTLrWrc%rxDa-q->cEz2`tPCjHr8P^Ukep1VH%%j;LX*j%M*G3N?n
z7Gpo+%6PWCBi&vGM~D~W6{Xtc6PTM?}LD2p)fL5*ICK7sX2rp8@?#RMcD!-G;yYc*9
zBK4;)zxr}3fp-%4vAmZ^H&Li3FZ}1k$cyCZ-Q@Z0$zIMnwF0eHi~
z)9@e54}B`<+^
zQUUR#(nMm9!Un;=g^b9K!`<(cOvH<-s;O0|s(Om5!uLlFj#<@S}8dVs-7WVvmZRhzrK8sgN^+efQOymo}6*z%zh}@6vfc*1aJ!AD+z`B
zA1wx`C_FU9-Vk`)1|5br!Y8#%a%-6Zmf=QE0q~@|_HwIEqSXe`Oh+#>nG+(xmkZ-<
z#dwc++1Aj@wx?P)7-d=iGt7n)l7C@zhN>SihPn6%2On@961`XULWZRg+Z#S4;K!31
zK~Z|)S``YPvH>pahv_We@uc{n`yu*qEB>Fbi-6;!+MWT}lmtO&$`L_sA`VhWh(C<+
z-#$va-Paz%Zuhm1K5^f7HRZ4{yeH4Q-PiumnXiBIP2bkg<(;9+t~|JR?1U>1!1euJ
zBn3q+48H|?$A((8gYbJ;+~Z+>52KT3H{`!6O)(ylo5xZAht1){N%0i|@P-2y4L30o
zMt0HIHX7TgxR||H*&Q_NqS^hyp|8{K@TB|cZ{5Md)?i_0u;8Mj&G1nH3glhz
disRnAhhV25ntw^3L*Ip_1?eB+$I`#}=6~d*aUTEx
literal 0
HcmV?d00001
diff --git a/test/types/aggregation_by_resource_and_metric_stub.py b/test/types/aggregation_by_resource_and_metric_stub.py
new file mode 100644
index 0000000..ca4d1b5
--- /dev/null
+++ b/test/types/aggregation_by_resource_and_metric_stub.py
@@ -0,0 +1,77 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_by_resource_and_metric import (
+ AggregationByResourceAndMetric,
+ )
+
+ AggregationByResourceAndMetricAdapter = TypeAdapter(AggregationByResourceAndMetric)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_by_resource_and_metric_model_schema = json.loads(
+ r"""{
+ "anyOf" : [ {
+ "title" : "Aggregation by Resource or Metric",
+ "type" : "object",
+ "additionalProperties" : {
+ "$ref" : "#/components/schemas/Aggregation_by_Resource_or_Metric"
+ },
+ "description" : "Aggregation methods specified per resource or metric.",
+ "nullable" : true
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_by_resource_and_metric_model_schema.update({
+ "definitions": MODEL_DEFINITIONS
+})
+
+aggregation_by_resource_and_metric_faker = JSF(
+ aggregation_by_resource_and_metric_model_schema, allow_none_optionals=1
+)
+
+
+class AggregationByResourceAndMetricStub:
+ """AggregationByResourceAndMetric unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_by_resource_and_metric_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AggregationByResourceAndMetric":
+ """Create AggregationByResourceAndMetric stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationByResourceAndMetricAdapter.json_schema(),
+ allow_none_optionals=1,
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationByResourceAndMetricAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregation_by_resource_or_metric_stub.py b/test/types/aggregation_by_resource_or_metric_stub.py
new file mode 100644
index 0000000..ccd6b14
--- /dev/null
+++ b/test/types/aggregation_by_resource_or_metric_stub.py
@@ -0,0 +1,79 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_by_resource_or_metric import (
+ AggregationByResourceOrMetric,
+ )
+
+ AggregationByResourceOrMetricAdapter = TypeAdapter(AggregationByResourceOrMetric)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_by_resource_or_metric_model_schema = json.loads(
+ r"""{
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/AggregationMethod"
+ }, {
+ "title" : "Aggregations",
+ "type" : "array",
+ "description" : "Aggregation methods, leading to sepearate series.",
+ "nullable" : true,
+ "items" : {
+ "$ref" : "#/components/schemas/Aggregations_inner"
+ }
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_by_resource_or_metric_model_schema.update({
+ "definitions": MODEL_DEFINITIONS
+})
+
+aggregation_by_resource_or_metric_faker = JSF(
+ aggregation_by_resource_or_metric_model_schema, allow_none_optionals=1
+)
+
+
+class AggregationByResourceOrMetricStub:
+ """AggregationByResourceOrMetric unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_by_resource_or_metric_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AggregationByResourceOrMetric":
+ """Create AggregationByResourceOrMetric stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationByResourceOrMetricAdapter.json_schema(),
+ allow_none_optionals=1,
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationByResourceOrMetricAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregation_method_one_of1_stub.py b/test/types/aggregation_method_one_of1_stub.py
new file mode 100644
index 0000000..72a5f81
--- /dev/null
+++ b/test/types/aggregation_method_one_of1_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_method_one_of1 import (
+ AggregationMethodOneOf1,
+ )
+
+ AggregationMethodOneOf1Adapter = TypeAdapter(AggregationMethodOneOf1)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_method_one_of_1_model_schema = json.loads(
+ r"""{
+ "title" : "AggregationMethod_oneOf_1",
+ "type" : "string",
+ "description" : "Use the last value (in time) to represent all data for the sample interval.",
+ "enum" : [ "last" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_method_one_of_1_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+aggregation_method_one_of_1_faker = JSF(
+ aggregation_method_one_of_1_model_schema, allow_none_optionals=1
+)
+
+
+class AggregationMethodOneOf1Stub:
+ """AggregationMethodOneOf1 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_method_one_of_1_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AggregationMethodOneOf1":
+ """Create AggregationMethodOneOf1 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationMethodOneOf1Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationMethodOneOf1Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregation_method_one_of2_stub.py b/test/types/aggregation_method_one_of2_stub.py
new file mode 100644
index 0000000..1abb11a
--- /dev/null
+++ b/test/types/aggregation_method_one_of2_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_method_one_of2 import (
+ AggregationMethodOneOf2,
+ )
+
+ AggregationMethodOneOf2Adapter = TypeAdapter(AggregationMethodOneOf2)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_method_one_of_2_model_schema = json.loads(
+ r"""{
+ "title" : "AggregationMethod_oneOf_2",
+ "type" : "string",
+ "description" : "Aggregate data by the mean value: The sum of values divided by number of observations.",
+ "enum" : [ "mean" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_method_one_of_2_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+aggregation_method_one_of_2_faker = JSF(
+ aggregation_method_one_of_2_model_schema, allow_none_optionals=1
+)
+
+
+class AggregationMethodOneOf2Stub:
+ """AggregationMethodOneOf2 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_method_one_of_2_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AggregationMethodOneOf2":
+ """Create AggregationMethodOneOf2 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationMethodOneOf2Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationMethodOneOf2Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregation_method_one_of3_stub.py b/test/types/aggregation_method_one_of3_stub.py
new file mode 100644
index 0000000..880b45e
--- /dev/null
+++ b/test/types/aggregation_method_one_of3_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_method_one_of3 import (
+ AggregationMethodOneOf3,
+ )
+
+ AggregationMethodOneOf3Adapter = TypeAdapter(AggregationMethodOneOf3)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_method_one_of_3_model_schema = json.loads(
+ r"""{
+ "title" : "AggregationMethod_oneOf_3",
+ "type" : "string",
+ "description" : "Aggregate data by the median value: The n/2-th value when ordered, the average of the (n-1)/2-th and (n+1)/2-th value when n is uneven.",
+ "enum" : [ "median" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_method_one_of_3_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+aggregation_method_one_of_3_faker = JSF(
+ aggregation_method_one_of_3_model_schema, allow_none_optionals=1
+)
+
+
+class AggregationMethodOneOf3Stub:
+ """AggregationMethodOneOf3 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_method_one_of_3_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AggregationMethodOneOf3":
+ """Create AggregationMethodOneOf3 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationMethodOneOf3Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationMethodOneOf3Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregation_method_one_of4_stub.py b/test/types/aggregation_method_one_of4_stub.py
new file mode 100644
index 0000000..40187cb
--- /dev/null
+++ b/test/types/aggregation_method_one_of4_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_method_one_of4 import (
+ AggregationMethodOneOf4,
+ )
+
+ AggregationMethodOneOf4Adapter = TypeAdapter(AggregationMethodOneOf4)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_method_one_of_4_model_schema = json.loads(
+ r"""{
+ "title" : "AggregationMethod_oneOf_4",
+ "type" : "string",
+ "description" : "The sum of all values summarizes the data for the sample interval.",
+ "enum" : [ "sum" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_method_one_of_4_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+aggregation_method_one_of_4_faker = JSF(
+ aggregation_method_one_of_4_model_schema, allow_none_optionals=1
+)
+
+
+class AggregationMethodOneOf4Stub:
+ """AggregationMethodOneOf4 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_method_one_of_4_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AggregationMethodOneOf4":
+ """Create AggregationMethodOneOf4 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationMethodOneOf4Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationMethodOneOf4Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregation_method_one_of5_stub.py b/test/types/aggregation_method_one_of5_stub.py
new file mode 100644
index 0000000..309932b
--- /dev/null
+++ b/test/types/aggregation_method_one_of5_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_method_one_of5 import (
+ AggregationMethodOneOf5,
+ )
+
+ AggregationMethodOneOf5Adapter = TypeAdapter(AggregationMethodOneOf5)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_method_one_of_5_model_schema = json.loads(
+ r"""{
+ "title" : "AggregationMethod_oneOf_5",
+ "type" : "string",
+ "description" : "Use the count of observations in the sample interval.",
+ "enum" : [ "count" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_method_one_of_5_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+aggregation_method_one_of_5_faker = JSF(
+ aggregation_method_one_of_5_model_schema, allow_none_optionals=1
+)
+
+
+class AggregationMethodOneOf5Stub:
+ """AggregationMethodOneOf5 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_method_one_of_5_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AggregationMethodOneOf5":
+ """Create AggregationMethodOneOf5 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationMethodOneOf5Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationMethodOneOf5Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregation_method_one_of6_stub.py b/test/types/aggregation_method_one_of6_stub.py
new file mode 100644
index 0000000..0cb80fe
--- /dev/null
+++ b/test/types/aggregation_method_one_of6_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_method_one_of6 import (
+ AggregationMethodOneOf6,
+ )
+
+ AggregationMethodOneOf6Adapter = TypeAdapter(AggregationMethodOneOf6)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_method_one_of_6_model_schema = json.loads(
+ r"""{
+ "title" : "AggregationMethod_oneOf_6",
+ "type" : "string",
+ "description" : "Use the standard deviation of all observations in the sample interval.",
+ "enum" : [ "std" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_method_one_of_6_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+aggregation_method_one_of_6_faker = JSF(
+ aggregation_method_one_of_6_model_schema, allow_none_optionals=1
+)
+
+
+class AggregationMethodOneOf6Stub:
+ """AggregationMethodOneOf6 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_method_one_of_6_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AggregationMethodOneOf6":
+ """Create AggregationMethodOneOf6 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationMethodOneOf6Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationMethodOneOf6Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregation_method_one_of7_stub.py b/test/types/aggregation_method_one_of7_stub.py
new file mode 100644
index 0000000..4de5489
--- /dev/null
+++ b/test/types/aggregation_method_one_of7_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_method_one_of7 import (
+ AggregationMethodOneOf7,
+ )
+
+ AggregationMethodOneOf7Adapter = TypeAdapter(AggregationMethodOneOf7)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_method_one_of_7_model_schema = json.loads(
+ r"""{
+ "title" : "AggregationMethod_oneOf_7",
+ "type" : "string",
+ "description" : "Use the maximum of all values in the sample interval.",
+ "enum" : [ "max" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_method_one_of_7_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+aggregation_method_one_of_7_faker = JSF(
+ aggregation_method_one_of_7_model_schema, allow_none_optionals=1
+)
+
+
+class AggregationMethodOneOf7Stub:
+ """AggregationMethodOneOf7 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_method_one_of_7_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AggregationMethodOneOf7":
+ """Create AggregationMethodOneOf7 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationMethodOneOf7Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationMethodOneOf7Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregation_method_one_of8_stub.py b/test/types/aggregation_method_one_of8_stub.py
new file mode 100644
index 0000000..ba8f966
--- /dev/null
+++ b/test/types/aggregation_method_one_of8_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_method_one_of8 import (
+ AggregationMethodOneOf8,
+ )
+
+ AggregationMethodOneOf8Adapter = TypeAdapter(AggregationMethodOneOf8)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_method_one_of_8_model_schema = json.loads(
+ r"""{
+ "title" : "AggregationMethod_oneOf_8",
+ "type" : "string",
+ "description" : "Use the minimum of all values in the sample interval.",
+ "enum" : [ "min" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_method_one_of_8_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+aggregation_method_one_of_8_faker = JSF(
+ aggregation_method_one_of_8_model_schema, allow_none_optionals=1
+)
+
+
+class AggregationMethodOneOf8Stub:
+ """AggregationMethodOneOf8 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_method_one_of_8_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AggregationMethodOneOf8":
+ """Create AggregationMethodOneOf8 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationMethodOneOf8Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationMethodOneOf8Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregation_method_one_of_stub.py b/test/types/aggregation_method_one_of_stub.py
new file mode 100644
index 0000000..60561e6
--- /dev/null
+++ b/test/types/aggregation_method_one_of_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_method_one_of import (
+ AggregationMethodOneOf,
+ )
+
+ AggregationMethodOneOfAdapter = TypeAdapter(AggregationMethodOneOf)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_method_one_of_model_schema = json.loads(
+ r"""{
+ "title" : "AggregationMethod_oneOf",
+ "type" : "string",
+ "description" : "Use the first value (in time) to represent all data for the sample interval.",
+ "enum" : [ "first" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_method_one_of_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+aggregation_method_one_of_faker = JSF(
+ aggregation_method_one_of_model_schema, allow_none_optionals=1
+)
+
+
+class AggregationMethodOneOfStub:
+ """AggregationMethodOneOf unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_method_one_of_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AggregationMethodOneOf":
+ """Create AggregationMethodOneOf stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationMethodOneOfAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationMethodOneOfAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregation_method_stub.py b/test/types/aggregation_method_stub.py
new file mode 100644
index 0000000..4d5f54e
--- /dev/null
+++ b/test/types/aggregation_method_stub.py
@@ -0,0 +1,80 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregation_method import AggregationMethod
+
+ AggregationMethodAdapter = TypeAdapter(AggregationMethod)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregation_method_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "nullable" : true,
+ "oneOf" : [ {
+ "$ref" : "#/components/schemas/AggregationMethod_oneOf"
+ }, {
+ "$ref" : "#/components/schemas/AggregationMethod_oneOf_1"
+ }, {
+ "$ref" : "#/components/schemas/AggregationMethod_oneOf_2"
+ }, {
+ "$ref" : "#/components/schemas/AggregationMethod_oneOf_3"
+ }, {
+ "$ref" : "#/components/schemas/AggregationMethod_oneOf_4"
+ }, {
+ "$ref" : "#/components/schemas/AggregationMethod_oneOf_5"
+ }, {
+ "$ref" : "#/components/schemas/AggregationMethod_oneOf_6"
+ }, {
+ "$ref" : "#/components/schemas/AggregationMethod_oneOf_7"
+ }, {
+ "$ref" : "#/components/schemas/AggregationMethod_oneOf_8"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregation_method_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+aggregation_method_faker = JSF(aggregation_method_model_schema, allow_none_optionals=1)
+
+
+class AggregationMethodStub:
+ """AggregationMethod unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregation_method_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "AggregationMethod":
+ """Create AggregationMethod stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationMethodAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationMethodAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/aggregations_inner_stub.py b/test/types/aggregations_inner_stub.py
new file mode 100644
index 0000000..6d77087
--- /dev/null
+++ b/test/types/aggregations_inner_stub.py
@@ -0,0 +1,62 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.aggregations_inner import AggregationsInner
+
+ AggregationsInnerAdapter = TypeAdapter(AggregationsInner)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+aggregations_inner_model_schema = json.loads(
+ r"""{
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/AggregationMethod"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+aggregations_inner_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+aggregations_inner_faker = JSF(aggregations_inner_model_schema, allow_none_optionals=1)
+
+
+class AggregationsInnerStub:
+ """AggregationsInner unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return aggregations_inner_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "AggregationsInner":
+ """Create AggregationsInner stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AggregationsInnerAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AggregationsInnerAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/align_at_stub.py b/test/types/align_at_stub.py
new file mode 100644
index 0000000..3aecf35
--- /dev/null
+++ b/test/types/align_at_stub.py
@@ -0,0 +1,58 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.align_at import AlignAt
+
+ AlignAtAdapter = TypeAdapter(AlignAt)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+align_at_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Possible values for `align.at`.\n\n* 'grid' Align to a fixed grid (possibly using timezone information)\n* 'from' Align a the `from` boundary\n* 'until' Align a the `until` boundary\n* 'boundary' Align a the `from` boundary if specified,\n otherwise the `until` boundary.\n\nWhen not specified, 'grid' is used.",
+ "enum" : [ "grid", "boundary", "from", "until" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+align_at_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+align_at_faker = JSF(align_at_model_schema, allow_none_optionals=1)
+
+
+class AlignAtStub:
+ """AlignAt unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return align_at_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "AlignAt":
+ """Create AlignAt stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(AlignAtAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AlignAtAdapter.validate_python(json, context={"skip_validation": True})
diff --git a/test/types/align_shift_stub.py b/test/types/align_shift_stub.py
new file mode 100644
index 0000000..8534d66
--- /dev/null
+++ b/test/types/align_shift_stub.py
@@ -0,0 +1,60 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.align_shift import AlignShift
+
+ AlignShiftAdapter = TypeAdapter(AlignShift)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+align_shift_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Possible values for `align.shift`.\n\n* 'backward': keep the window size of the original interval specification,\n shifting back.\n* 'forward': keep the window size of the original interval specification,\n shifting forward.\n* 'wrap': enlarge the window size to include all of the original interval.\n\nWhen not specified, 'backward' is used.",
+ "enum" : [ "backward", "forward", "wrap" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+align_shift_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+align_shift_faker = JSF(align_shift_model_schema, allow_none_optionals=1)
+
+
+class AlignShiftStub:
+ """AlignShift unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return align_shift_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "AlignShift":
+ """Create AlignShift stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(AlignShiftAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AlignShiftAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/alignment_grid_interval_stub.py b/test/types/alignment_grid_interval_stub.py
new file mode 100644
index 0000000..a8f4aa3
--- /dev/null
+++ b/test/types/alignment_grid_interval_stub.py
@@ -0,0 +1,78 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.alignment_grid_interval import (
+ AlignmentGridInterval,
+ )
+
+ AlignmentGridIntervalAdapter = TypeAdapter(AlignmentGridInterval)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+alignment_grid_interval__model_schema = json.loads(
+ r"""{
+ "title" : "Alignment Grid interval.",
+ "type" : "string",
+ "description" : "\nDefines the grid used to align the aggregation window.\nThe window will align at whole-unit multiples of this interval.\n\nFor intervals like `PT1D`, that are timezone-dependent, use the \n`align.timezone` to fix the absolute timestamp of the grid boundaries.\n\nIf not specified, defaults to the `freq` aggregation interval.\n",
+ "oneOf" : [ {
+ "title" : "ISO8601 period ",
+ "pattern" : "^P([0-9]+Y)?([0-9]+M)?([0-9]+W)?([0-9]+D)?(T([0-9]+H)?([0-9]+M)?([0-9]+(\\.[0-9]*)?S)?)?$",
+ "type" : "string",
+ "description" : "A period in [ISO8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations) format.",
+ "format" : "period",
+ "example" : "PT3H15M"
+ }, {
+ "$ref" : "#/components/schemas/Grouping_Interval_Override_oneOf"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+alignment_grid_interval__model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+alignment_grid_interval__faker = JSF(
+ alignment_grid_interval__model_schema, allow_none_optionals=1
+)
+
+
+class AlignmentGridIntervalStub:
+ """AlignmentGridInterval unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return alignment_grid_interval__faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "AlignmentGridInterval":
+ """Create AlignmentGridInterval stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AlignmentGridIntervalAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AlignmentGridIntervalAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/alignment_stub.py b/test/types/alignment_stub.py
new file mode 100644
index 0000000..90e1483
--- /dev/null
+++ b/test/types/alignment_stub.py
@@ -0,0 +1,72 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.alignment import Alignment
+
+ AlignmentAdapter = TypeAdapter(Alignment)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+alignment_model_schema = json.loads(
+ r"""{
+ "type" : "object",
+ "properties" : {
+ "at" : {
+ "$ref" : "#/components/schemas/AlignAt"
+ },
+ "shift" : {
+ "$ref" : "#/components/schemas/AlignShift"
+ },
+ "freq" : {
+ "$ref" : "#/components/schemas/Alignment_Grid_interval_"
+ },
+ "timezone" : {
+ "$ref" : "#/components/schemas/Alignment_Timezone_"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Aggregation Alignment Options.\n\nSpecifies how the aggregation grid is aligned."
+}
+""",
+ object_hook=with_example_provider,
+)
+alignment_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+alignment_faker = JSF(alignment_model_schema, allow_none_optionals=1)
+
+
+class AlignmentStub:
+ """Alignment unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return alignment_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "Alignment":
+ """Create Alignment stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(AlignmentAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AlignmentAdapter.validate_python(json, context={"skip_validation": True})
diff --git a/test/types/alignment_timezone_stub.py b/test/types/alignment_timezone_stub.py
new file mode 100644
index 0000000..86b3a02
--- /dev/null
+++ b/test/types/alignment_timezone_stub.py
@@ -0,0 +1,74 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.alignment_timezone import AlignmentTimezone
+
+ AlignmentTimezoneAdapter = TypeAdapter(AlignmentTimezone)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+alignment_timezone__model_schema = json.loads(
+ r"""{
+ "title" : "Alignment Timezone.",
+ "type" : "string",
+ "description" : "\nThe timezone to use when shifting boundaries, especially\nat day granularity.\nAlso affects the rendering of timestamps when\n`render.iso_timestamp` is enabled.\n\nWhen not specified, the `UTC` timezone is used.\n",
+ "oneOf" : [ {
+ "title" : "Timezone Identifier",
+ "type" : "string",
+ "description" : "[ICANN timezone identifier](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)"
+ }, {
+ "title" : "UTC Offset",
+ "pattern" : "(+|-)\\d\\d:\\d\\d",
+ "type" : "string",
+ "description" : "[UTC offset](https://en.wikipedia.org/wiki/UTC_offset)"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+alignment_timezone__model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+alignment_timezone__faker = JSF(
+ alignment_timezone__model_schema, allow_none_optionals=1
+)
+
+
+class AlignmentTimezoneStub:
+ """AlignmentTimezone unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return alignment_timezone__faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "AlignmentTimezone":
+ """Create AlignmentTimezone stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ AlignmentTimezoneAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return AlignmentTimezoneAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/cause_exception_stub.py b/test/types/cause_exception_stub.py
new file mode 100644
index 0000000..50a9da4
--- /dev/null
+++ b/test/types/cause_exception_stub.py
@@ -0,0 +1,80 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.cause_exception import CauseException
+
+ CauseExceptionAdapter = TypeAdapter(CauseException)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+cause_exception_model_schema = json.loads(
+ r"""{
+ "required" : [ "message", "stacktrace", "type" ],
+ "type" : "object",
+ "properties" : {
+ "type" : {
+ "title" : "Exception Type",
+ "type" : "string"
+ },
+ "message" : {
+ "title" : "Exception Message",
+ "type" : "string"
+ },
+ "stacktrace" : {
+ "title" : "Stack Trace",
+ "type" : "array",
+ "items" : {
+ "type" : "string"
+ }
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Describes the exception that caused a message."
+}
+""",
+ object_hook=with_example_provider,
+)
+cause_exception_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+cause_exception_faker = JSF(cause_exception_model_schema, allow_none_optionals=1)
+
+
+class CauseExceptionStub:
+ """CauseException unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return cause_exception_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "CauseException":
+ """Create CauseException stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ CauseExceptionAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return CauseExceptionAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/column_data_set_data_axis_stub.py b/test/types/column_data_set_data_axis_stub.py
new file mode 100644
index 0000000..cd85c8b
--- /dev/null
+++ b/test/types/column_data_set_data_axis_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.column_data_set_data_axis import (
+ ColumnDataSetDataAxis,
+ )
+
+ ColumnDataSetDataAxisAdapter = TypeAdapter(ColumnDataSetDataAxis)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+column_data_set_data_axis_model_schema = json.loads(
+ r"""{
+ "title" : "ColumnDataSet_data_axis",
+ "type" : "string",
+ "default" : "row",
+ "enum" : [ "row" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+column_data_set_data_axis_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+column_data_set_data_axis_faker = JSF(
+ column_data_set_data_axis_model_schema, allow_none_optionals=1
+)
+
+
+class ColumnDataSetDataAxisStub:
+ """ColumnDataSetDataAxis unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return column_data_set_data_axis_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "ColumnDataSetDataAxis":
+ """Create ColumnDataSetDataAxis stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ ColumnDataSetDataAxisAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return ColumnDataSetDataAxisAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/column_data_set_stub.py b/test/types/column_data_set_stub.py
new file mode 100644
index 0000000..9e3d668
--- /dev/null
+++ b/test/types/column_data_set_stub.py
@@ -0,0 +1,93 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.column_data_set import ColumnDataSet
+
+ ColumnDataSetAdapter = TypeAdapter(ColumnDataSet)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+column_data_set_model_schema = json.loads(
+ r"""{
+ "required" : [ "data", "rows" ],
+ "type" : "object",
+ "properties" : {
+ "attributes" : {
+ "$ref" : "#/components/schemas/DataSetAttributes"
+ },
+ "window_spec" : {
+ "$ref" : "#/components/schemas/DataSetWindow"
+ },
+ "data_axis" : {
+ "$ref" : "#/components/schemas/ColumnDataSet_data_axis"
+ },
+ "rows" : {
+ "title" : "Row Headers",
+ "type" : "array",
+ "description" : "Header Attributes for the index data.\n\nThe initial string-valued headers (normally `resource`, `metric`,`aggregation`) indicate that row to contain series attributes.\n\nThe remaining object-valued row headers contain the index data.",
+ "items" : {
+ "$ref" : "#/components/schemas/Row_Headers_inner"
+ }
+ },
+ "data" : {
+ "title" : "Series",
+ "type" : "array",
+ "description" : "All metric observation values for a single series. Prefixed by the series attributes.",
+ "items" : {
+ "type" : "array",
+ "items" : {
+ "$ref" : "#/components/schemas/Datum"
+ }
+ }
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Column-oriented dataset with rows header.\n\nTimeseries data layout with a rows header containing\nthe index data.\nThe data array contains series data prefixed by series attributes.\nThe `rows` index is prefix by the names of these series attributes.\nResult for render options `data_axis=row` and `header_array=column`."
+}
+""",
+ object_hook=with_example_provider,
+)
+column_data_set_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+column_data_set_faker = JSF(column_data_set_model_schema, allow_none_optionals=1)
+
+
+class ColumnDataSetStub:
+ """ColumnDataSet unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return column_data_set_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "ColumnDataSet":
+ """Create ColumnDataSet stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ ColumnDataSetAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return ColumnDataSetAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/column_header_stub.py b/test/types/column_header_stub.py
new file mode 100644
index 0000000..ae011cc
--- /dev/null
+++ b/test/types/column_header_stub.py
@@ -0,0 +1,77 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.column_header import ColumnHeader
+
+ ColumnHeaderAdapter = TypeAdapter(ColumnHeader)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+column_header_model_schema = json.loads(
+ r"""{
+ "required" : [ "metric", "resource" ],
+ "type" : "object",
+ "properties" : {
+ "resource" : {
+ "title" : "Series resource id",
+ "type" : "string"
+ },
+ "metric" : {
+ "title" : "Series metric",
+ "type" : "string"
+ },
+ "aggregation" : {
+ "title" : "Aggregation applied to the series.",
+ "type" : "string"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Column attributes.\n\nAttributes that identify and describe the data in this column."
+}
+""",
+ object_hook=with_example_provider,
+)
+column_header_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+column_header_faker = JSF(column_header_model_schema, allow_none_optionals=1)
+
+
+class ColumnHeaderStub:
+ """ColumnHeader unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return column_header_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "ColumnHeader":
+ """Create ColumnHeader stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ ColumnHeaderAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return ColumnHeaderAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/column_headers_inner_stub.py b/test/types/column_headers_inner_stub.py
new file mode 100644
index 0000000..bdf14a0
--- /dev/null
+++ b/test/types/column_headers_inner_stub.py
@@ -0,0 +1,67 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.column_headers_inner import ColumnHeadersInner
+
+ ColumnHeadersInnerAdapter = TypeAdapter(ColumnHeadersInner)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+column_headers_inner_model_schema = json.loads(
+ r"""{
+ "title" : "Column_Headers_inner",
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/RowIndexColumnHeader"
+ }, {
+ "$ref" : "#/components/schemas/ColumnHeader"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+column_headers_inner_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+column_headers_inner_faker = JSF(
+ column_headers_inner_model_schema, allow_none_optionals=1
+)
+
+
+class ColumnHeadersInnerStub:
+ """ColumnHeadersInner unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return column_headers_inner_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "ColumnHeadersInner":
+ """Create ColumnHeadersInner stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ ColumnHeadersInnerAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return ColumnHeadersInnerAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/data_axis_option_stub.py b/test/types/data_axis_option_stub.py
new file mode 100644
index 0000000..a362d11
--- /dev/null
+++ b/test/types/data_axis_option_stub.py
@@ -0,0 +1,62 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.data_axis_option import DataAxisOption
+
+ DataAxisOptionAdapter = TypeAdapter(DataAxisOption)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+data_axis_option_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Allowed values for the render.data_axis option.",
+ "enum" : [ "row", "column" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+data_axis_option_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+data_axis_option_faker = JSF(data_axis_option_model_schema, allow_none_optionals=1)
+
+
+class DataAxisOptionStub:
+ """DataAxisOption unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return data_axis_option_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "DataAxisOption":
+ """Create DataAxisOption stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ DataAxisOptionAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return DataAxisOptionAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/data_set_attributes_stub.py b/test/types/data_set_attributes_stub.py
new file mode 100644
index 0000000..0258bc6
--- /dev/null
+++ b/test/types/data_set_attributes_stub.py
@@ -0,0 +1,70 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.data_set_attributes import DataSetAttributes
+
+ DataSetAttributesAdapter = TypeAdapter(DataSetAttributes)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+data_set_attributes_model_schema = json.loads(
+ r"""{
+ "title" : "DataSetAttributes",
+ "type" : "object",
+ "properties" : {
+ "role" : {
+ "$ref" : "#/components/schemas/Role"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Data Set Attributes.\n\nData attributes that apply to all data in this set."
+}
+""",
+ object_hook=with_example_provider,
+)
+data_set_attributes_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+data_set_attributes_faker = JSF(
+ data_set_attributes_model_schema, allow_none_optionals=1
+)
+
+
+class DataSetAttributesStub:
+ """DataSetAttributes unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return data_set_attributes_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "DataSetAttributes":
+ """Create DataSetAttributes stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ DataSetAttributesAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return DataSetAttributesAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/data_set_window_stub.py b/test/types/data_set_window_stub.py
new file mode 100644
index 0000000..2558bef
--- /dev/null
+++ b/test/types/data_set_window_stub.py
@@ -0,0 +1,83 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.data_set_window import DataSetWindow
+
+ DataSetWindowAdapter = TypeAdapter(DataSetWindow)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+data_set_window_model_schema = json.loads(
+ r"""{
+ "title" : "DataSetWindow",
+ "required" : [ "freq", "until", "window" ],
+ "type" : "object",
+ "properties" : {
+ "until" : {
+ "title" : "Time Axis End",
+ "type" : "integer",
+ "description" : "Exclusive higher bound of the time axis in unix epoch milliseconds."
+ },
+ "window" : {
+ "title" : "Time Axis Length",
+ "type" : "string",
+ "description" : "Time axis length as ISO8601 period.",
+ "format" : "period"
+ },
+ "freq" : {
+ "title" : "Frequency",
+ "type" : "string",
+ "description" : "Time axis aggregation interval as an ISO8601 period .",
+ "format" : "period"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Data Window.\n\nStatistics of the time axis of a data set.\nPresent with render option `include_window_spec=true`.\","
+}
+""",
+ object_hook=with_example_provider,
+)
+data_set_window_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+data_set_window_faker = JSF(data_set_window_model_schema, allow_none_optionals=1)
+
+
+class DataSetWindowStub:
+ """DataSetWindow unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return data_set_window_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "DataSetWindow":
+ """Create DataSetWindow stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ DataSetWindowAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return DataSetWindowAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/datum_stub.py b/test/types/datum_stub.py
new file mode 100644
index 0000000..1365a38
--- /dev/null
+++ b/test/types/datum_stub.py
@@ -0,0 +1,67 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.datum import Datum
+
+ DatumAdapter = TypeAdapter(Datum)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+datum_model_schema = json.loads(
+ r"""{
+ "title" : "Datum",
+ "description" : "A single metric value for a timeseries.\n\nA null value indicates that no (aggregated/interpolated) value exists for the corresponding timestamp.",
+ "oneOf" : [ {
+ "type" : "number",
+ "nullable" : true
+ }, {
+ "type" : "string",
+ "nullable" : true
+ }, {
+ "type" : "boolean",
+ "nullable" : true
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+datum_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+datum_faker = JSF(datum_model_schema, allow_none_optionals=1)
+
+
+class DatumStub:
+ """Datum unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return datum_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "Datum":
+ """Create Datum stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(DatumAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return DatumAdapter.validate_python(json, context={"skip_validation": True})
diff --git a/test/types/default_aggregation_stub.py b/test/types/default_aggregation_stub.py
new file mode 100644
index 0000000..6120d1f
--- /dev/null
+++ b/test/types/default_aggregation_stub.py
@@ -0,0 +1,90 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.default_aggregation import DefaultAggregation
+
+ DefaultAggregationAdapter = TypeAdapter(DefaultAggregation)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+default_aggregation_model_schema = json.loads(
+ r"""{
+ "title" : "Default Aggregation",
+ "description" : "Default aggregation method(s) for the series in the query.",
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/AggregationMethod"
+ }, {
+ "title" : "Aggregations",
+ "type" : "array",
+ "description" : "Aggregation methods, leading to sepearate series.",
+ "nullable" : true,
+ "items" : {
+ "$ref" : "#/components/schemas/Aggregations_inner"
+ }
+ }, {
+ "title" : "Aggregation by Resource or Metric",
+ "type" : "object",
+ "additionalProperties" : {
+ "$ref" : "#/components/schemas/Aggregation_by_Resource_or_Metric"
+ },
+ "description" : "Aggregation methods specified per resource or metric.",
+ "nullable" : true
+ }, {
+ "title" : "Aggregation by Resource and Metric",
+ "type" : "object",
+ "additionalProperties" : {
+ "$ref" : "#/components/schemas/Aggregation_by_Resource_and_Metric"
+ },
+ "description" : "Aggregation methods specified per resource and metric.",
+ "nullable" : true
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+default_aggregation_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+default_aggregation_faker = JSF(
+ default_aggregation_model_schema, allow_none_optionals=1
+)
+
+
+class DefaultAggregationStub:
+ """DefaultAggregation unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return default_aggregation_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "DefaultAggregation":
+ """Create DefaultAggregation stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ DefaultAggregationAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return DefaultAggregationAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/default_interpolation_stub.py b/test/types/default_interpolation_stub.py
new file mode 100644
index 0000000..1d9c1c8
--- /dev/null
+++ b/test/types/default_interpolation_stub.py
@@ -0,0 +1,72 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.default_interpolation import (
+ DefaultInterpolation,
+ )
+
+ DefaultInterpolationAdapter = TypeAdapter(DefaultInterpolation)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+default_interpolation_model_schema = json.loads(
+ r"""{
+ "title" : "Default Interpolation",
+ "description" : "Default Interpolation method for the series (if aggregated).",
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/InterpolationMethod"
+ }, {
+ "$ref" : "#/components/schemas/InterpolationSpec"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+default_interpolation_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+default_interpolation_faker = JSF(
+ default_interpolation_model_schema, allow_none_optionals=1
+)
+
+
+class DefaultInterpolationStub:
+ """DefaultInterpolation unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return default_interpolation_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "DefaultInterpolation":
+ """Create DefaultInterpolation stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ DefaultInterpolationAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return DefaultInterpolationAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/delete_response_stub.py b/test/types/delete_response_stub.py
new file mode 100644
index 0000000..8ec8137
--- /dev/null
+++ b/test/types/delete_response_stub.py
@@ -0,0 +1,87 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.delete_response import DeleteResponse
+
+ DeleteResponseAdapter = TypeAdapter(DeleteResponse)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+delete_response_model_schema = json.loads(
+ r"""{
+ "type" : "object",
+ "properties" : {
+ "messages" : {
+ "title" : "Messages",
+ "type" : "array",
+ "items" : {
+ "$ref" : "#/components/schemas/Message"
+ }
+ },
+ "_links" : {
+ "title" : " Links",
+ "type" : "object",
+ "additionalProperties" : {
+ "$ref" : "#/components/schemas/_Links"
+ },
+ "description" : "HAL links, indexed by link relation."
+ },
+ "_embeddings" : {
+ "title" : " Embeddings",
+ "type" : "object",
+ "additionalProperties" : {
+ "$ref" : "#/components/schemas/_Embeddings"
+ },
+ "description" : "Hal embeddings, indexed by relation."
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Confirmation of a delete request."
+}
+""",
+ object_hook=with_example_provider,
+)
+delete_response_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+delete_response_faker = JSF(delete_response_model_schema, allow_none_optionals=1)
+
+
+class DeleteResponseStub:
+ """DeleteResponse unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return delete_response_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "DeleteResponse":
+ """Create DeleteResponse stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ DeleteResponseAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return DeleteResponseAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/embeddings_stub.py b/test/types/embeddings_stub.py
new file mode 100644
index 0000000..fa4ff67
--- /dev/null
+++ b/test/types/embeddings_stub.py
@@ -0,0 +1,66 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.embeddings import Embeddings
+
+ EmbeddingsAdapter = TypeAdapter(Embeddings)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+embeddings_model_schema = json.loads(
+ r"""{
+ "title" : "_Embeddings",
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/HALEmbedding"
+ }, {
+ "type" : "array",
+ "items" : {
+ "$ref" : "#/components/schemas/HALEmbedding"
+ }
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+embeddings_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+embeddings_faker = JSF(embeddings_model_schema, allow_none_optionals=1)
+
+
+class EmbeddingsStub:
+ """Embeddings unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return embeddings_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "Embeddings":
+ """Create Embeddings stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(EmbeddingsAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return EmbeddingsAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/from_override_stub.py b/test/types/from_override_stub.py
new file mode 100644
index 0000000..6700d95
--- /dev/null
+++ b/test/types/from_override_stub.py
@@ -0,0 +1,82 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.from_override import FromOverride
+
+ FromOverrideAdapter = TypeAdapter(FromOverride)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+from_override__model_schema = json.loads(
+ r"""{
+ "title" : "From Override.",
+ "type" : "string",
+ "oneOf" : [ {
+ "title" : "ISO8601 absolute timestamp",
+ "pattern" : "[0-9]{4}-[0-9]{2}-[0-9]{2}(T.*)?",
+ "type" : "string",
+ "description" : "A date or date-time in [ISO8601](https://en.wikipedia.org/wiki/ISO_8601#Combined_date_and_time_representations) format. When no timezone is specified, the UTC timezone is assumed (`+00:00`)",
+ "format" : "date-time",
+ "example" : "2018-03-21T12:23:00+01:00"
+ }, {
+ "title" : "UNIX epoch milliseconds",
+ "minimum" : 0,
+ "type" : "integer",
+ "description" : "Absolute timestamp milliseconds in unix epoch since 1970-01-01.",
+ "example" : 1534836422284
+ }, {
+ "title" : "ISO8601 Period Before Now",
+ "pattern" : "^P([0-9]+Y)?([0-9]+M)?([0-9]+W)?([0-9]+D)?(T([0-9]+H)?([0-9]+M)?([0-9]+(\\.[0-9]*)?S)?)?$",
+ "type" : "string",
+ "description" : "Specifies a timestamp before _now_ as a period in [ISO8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations) format.",
+ "format" : "period",
+ "example" : "PT3H15M"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+from_override__model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+from_override__faker = JSF(from_override__model_schema, allow_none_optionals=1)
+
+
+class FromOverrideStub:
+ """FromOverride unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return from_override__faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "FromOverride":
+ """Create FromOverride stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ FromOverrideAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return FromOverrideAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/grouping_interval_override_one_of_stub.py b/test/types/grouping_interval_override_one_of_stub.py
new file mode 100644
index 0000000..65ddf4b
--- /dev/null
+++ b/test/types/grouping_interval_override_one_of_stub.py
@@ -0,0 +1,71 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.grouping_interval_override_one_of import (
+ GroupingIntervalOverrideOneOf,
+ )
+
+ GroupingIntervalOverrideOneOfAdapter = TypeAdapter(GroupingIntervalOverrideOneOf)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+grouping_interval_override_one_of_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "When `inferred` is specified, the frequency of aggregation will be inferred from the main/first time series. This can be used to regularize the time series",
+ "enum" : [ "inferred" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+grouping_interval_override_one_of_model_schema.update({
+ "definitions": MODEL_DEFINITIONS
+})
+
+grouping_interval_override_one_of_faker = JSF(
+ grouping_interval_override_one_of_model_schema, allow_none_optionals=1
+)
+
+
+class GroupingIntervalOverrideOneOfStub:
+ """GroupingIntervalOverrideOneOf unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return grouping_interval_override_one_of_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "GroupingIntervalOverrideOneOf":
+ """Create GroupingIntervalOverrideOneOf stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ GroupingIntervalOverrideOneOfAdapter.json_schema(),
+ allow_none_optionals=1,
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return GroupingIntervalOverrideOneOfAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/grouping_interval_override_stub.py b/test/types/grouping_interval_override_stub.py
new file mode 100644
index 0000000..3b34ce4
--- /dev/null
+++ b/test/types/grouping_interval_override_stub.py
@@ -0,0 +1,78 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.grouping_interval_override import (
+ GroupingIntervalOverride,
+ )
+
+ GroupingIntervalOverrideAdapter = TypeAdapter(GroupingIntervalOverride)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+grouping_interval_override_model_schema = json.loads(
+ r"""{
+ "title" : "Grouping Interval Override",
+ "type" : "string",
+ "description" : "Override for the `freq` query attribute.",
+ "oneOf" : [ {
+ "title" : "ISO8601 period ",
+ "pattern" : "^P([0-9]+Y)?([0-9]+M)?([0-9]+W)?([0-9]+D)?(T([0-9]+H)?([0-9]+M)?([0-9]+(\\.[0-9]*)?S)?)?$",
+ "type" : "string",
+ "description" : "A period in [ISO8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations) format.",
+ "format" : "period",
+ "example" : "PT3H15M"
+ }, {
+ "$ref" : "#/components/schemas/Grouping_Interval_Override_oneOf"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+grouping_interval_override_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+grouping_interval_override_faker = JSF(
+ grouping_interval_override_model_schema, allow_none_optionals=1
+)
+
+
+class GroupingIntervalOverrideStub:
+ """GroupingIntervalOverride unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return grouping_interval_override_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "GroupingIntervalOverride":
+ """Create GroupingIntervalOverride stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ GroupingIntervalOverrideAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return GroupingIntervalOverrideAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/grouping_interval_stub.py b/test/types/grouping_interval_stub.py
new file mode 100644
index 0000000..0e84994
--- /dev/null
+++ b/test/types/grouping_interval_stub.py
@@ -0,0 +1,72 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.grouping_interval import GroupingInterval
+
+ GroupingIntervalAdapter = TypeAdapter(GroupingInterval)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+grouping_interval_model_schema = json.loads(
+ r"""{
+ "title" : "Grouping interval",
+ "type" : "string",
+ "description" : "Interval used to aggregate or regularize data. One of the [time line](https://docs.waylay.io/#/api/query/?id=time-line-properties) specifiers.",
+ "oneOf" : [ {
+ "title" : "ISO8601 period ",
+ "pattern" : "^P([0-9]+Y)?([0-9]+M)?([0-9]+W)?([0-9]+D)?(T([0-9]+H)?([0-9]+M)?([0-9]+(\\.[0-9]*)?S)?)?$",
+ "type" : "string",
+ "description" : "A period in [ISO8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations) format.",
+ "format" : "period",
+ "example" : "PT3H15M"
+ }, {
+ "$ref" : "#/components/schemas/Grouping_Interval_Override_oneOf"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+grouping_interval_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+grouping_interval_faker = JSF(grouping_interval_model_schema, allow_none_optionals=1)
+
+
+class GroupingIntervalStub:
+ """GroupingInterval unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return grouping_interval_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "GroupingInterval":
+ """Create GroupingInterval stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ GroupingIntervalAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return GroupingIntervalAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/hal_link_method_stub.py b/test/types/hal_link_method_stub.py
new file mode 100644
index 0000000..2a0c0dd
--- /dev/null
+++ b/test/types/hal_link_method_stub.py
@@ -0,0 +1,63 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.hal_link_method import HALLinkMethod
+
+ HALLinkMethodAdapter = TypeAdapter(HALLinkMethod)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+hal_link_method_model_schema = json.loads(
+ r"""{
+ "title" : "HALLinkMethod",
+ "type" : "string",
+ "description" : "An http method that can be specified in a HAL link.",
+ "enum" : [ "GET", "POST", "PUT", "DELETE", "PATCH" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+hal_link_method_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+hal_link_method_faker = JSF(hal_link_method_model_schema, allow_none_optionals=1)
+
+
+class HALLinkMethodStub:
+ """HALLinkMethod unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return hal_link_method_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "HALLinkMethod":
+ """Create HALLinkMethod stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ HALLinkMethodAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return HALLinkMethodAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/hal_link_role_stub.py b/test/types/hal_link_role_stub.py
new file mode 100644
index 0000000..f0ab95c
--- /dev/null
+++ b/test/types/hal_link_role_stub.py
@@ -0,0 +1,60 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.hal_link_role import HALLinkRole
+
+ HALLinkRoleAdapter = TypeAdapter(HALLinkRole)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+hal_link_role_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Supported link and embedding roles in HAL representations.",
+ "enum" : [ "self", "first", "prev", "next", "last", "execute" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+hal_link_role_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+hal_link_role_faker = JSF(hal_link_role_model_schema, allow_none_optionals=1)
+
+
+class HALLinkRoleStub:
+ """HALLinkRole unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return hal_link_role_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "HALLinkRole":
+ """Create HALLinkRole stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(HALLinkRoleAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return HALLinkRoleAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/hal_link_stub.py b/test/types/hal_link_stub.py
new file mode 100644
index 0000000..222255c
--- /dev/null
+++ b/test/types/hal_link_stub.py
@@ -0,0 +1,74 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.hal_link import HALLink
+
+ HALLinkAdapter = TypeAdapter(HALLink)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+hal_link_model_schema = json.loads(
+ r"""{
+ "required" : [ "href" ],
+ "type" : "object",
+ "properties" : {
+ "href" : {
+ "title" : "Link URL",
+ "type" : "string",
+ "description" : "Target url for this link."
+ },
+ "type" : {
+ "title" : "Link type",
+ "type" : "string",
+ "description" : "Type of the resource referenced by this link."
+ },
+ "method" : {
+ "$ref" : "#/components/schemas/HALLinkMethod"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "A link target in a HAL response."
+}
+""",
+ object_hook=with_example_provider,
+)
+hal_link_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+hal_link_faker = JSF(hal_link_model_schema, allow_none_optionals=1)
+
+
+class HALLinkStub:
+ """HALLink unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return hal_link_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "HALLink":
+ """Create HALLink stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(HALLinkAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return HALLinkAdapter.validate_python(json, context={"skip_validation": True})
diff --git a/test/types/header_array_option_stub.py b/test/types/header_array_option_stub.py
new file mode 100644
index 0000000..f14b5c7
--- /dev/null
+++ b/test/types/header_array_option_stub.py
@@ -0,0 +1,64 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.header_array_option import HeaderArrayOption
+
+ HeaderArrayOptionAdapter = TypeAdapter(HeaderArrayOption)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+header_array_option_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Allowed values for the render.header_array option.",
+ "enum" : [ "row", "column" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+header_array_option_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+header_array_option_faker = JSF(
+ header_array_option_model_schema, allow_none_optionals=1
+)
+
+
+class HeaderArrayOptionStub:
+ """HeaderArrayOption unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return header_array_option_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "HeaderArrayOption":
+ """Create HeaderArrayOption stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ HeaderArrayOptionAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return HeaderArrayOptionAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/hierarchical_stub.py b/test/types/hierarchical_stub.py
new file mode 100644
index 0000000..05d952e
--- /dev/null
+++ b/test/types/hierarchical_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.hierarchical import Hierarchical
+
+ HierarchicalAdapter = TypeAdapter(Hierarchical)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+hierarchical_model_schema = json.loads(
+ r"""{
+ "title" : "Hierarchical",
+ "description" : "if true, use hierarchical objects to represent multiple row (or column) dimensions, otherwise multi-keys get concatenated with a dot-delimiter. If the value is a list, only these levels are kept as separate levels, while remaining levels get concatenated keys",
+ "anyOf" : [ {
+ "type" : "boolean"
+ }, {
+ "type" : "array",
+ "items" : {
+ "type" : "string"
+ }
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+hierarchical_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+hierarchical_faker = JSF(hierarchical_model_schema, allow_none_optionals=1)
+
+
+class HierarchicalStub:
+ """Hierarchical unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return hierarchical_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "Hierarchical":
+ """Create Hierarchical stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ HierarchicalAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return HierarchicalAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/http_validation_error_stub.py b/test/types/http_validation_error_stub.py
new file mode 100644
index 0000000..8cffe43
--- /dev/null
+++ b/test/types/http_validation_error_stub.py
@@ -0,0 +1,73 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.http_validation_error import HTTPValidationError
+
+ HTTPValidationErrorAdapter = TypeAdapter(HTTPValidationError)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+http_validation_error_model_schema = json.loads(
+ r"""{
+ "type" : "object",
+ "properties" : {
+ "detail" : {
+ "title" : "Detail",
+ "type" : "array",
+ "items" : {
+ "$ref" : "#/components/schemas/ValidationError"
+ }
+ }
+ }
+}
+""",
+ object_hook=with_example_provider,
+)
+http_validation_error_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+http_validation_error_faker = JSF(
+ http_validation_error_model_schema, allow_none_optionals=1
+)
+
+
+class HTTPValidationErrorStub:
+ """HTTPValidationError unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return http_validation_error_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "HTTPValidationError":
+ """Create HTTPValidationError stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ HTTPValidationErrorAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return HTTPValidationErrorAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of10_stub.py b/test/types/interpolation_method_one_of10_stub.py
new file mode 100644
index 0000000..e15b602
--- /dev/null
+++ b/test/types/interpolation_method_one_of10_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of10 import (
+ InterpolationMethodOneOf10,
+ )
+
+ InterpolationMethodOneOf10Adapter = TypeAdapter(InterpolationMethodOneOf10)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_10_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Interpolate with a spline function of a user-specified order.",
+ "enum" : [ "spline" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_10_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_10_faker = JSF(
+ interpolation_method_one_of_10_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf10Stub:
+ """InterpolationMethodOneOf10 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_10_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf10":
+ """Create InterpolationMethodOneOf10 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf10Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf10Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of11_stub.py b/test/types/interpolation_method_one_of11_stub.py
new file mode 100644
index 0000000..a4c040a
--- /dev/null
+++ b/test/types/interpolation_method_one_of11_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of11 import (
+ InterpolationMethodOneOf11,
+ )
+
+ InterpolationMethodOneOf11Adapter = TypeAdapter(InterpolationMethodOneOf11)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_11_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Interpolate with the derivative of order 1.",
+ "enum" : [ "from_derivatives" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_11_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_11_faker = JSF(
+ interpolation_method_one_of_11_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf11Stub:
+ """InterpolationMethodOneOf11 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_11_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf11":
+ """Create InterpolationMethodOneOf11 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf11Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf11Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of12_stub.py b/test/types/interpolation_method_one_of12_stub.py
new file mode 100644
index 0000000..c5ae03b
--- /dev/null
+++ b/test/types/interpolation_method_one_of12_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of12 import (
+ InterpolationMethodOneOf12,
+ )
+
+ InterpolationMethodOneOf12Adapter = TypeAdapter(InterpolationMethodOneOf12)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_12_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Interpolate with a piecewise cubic spline function.",
+ "enum" : [ "pchip" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_12_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_12_faker = JSF(
+ interpolation_method_one_of_12_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf12Stub:
+ """InterpolationMethodOneOf12 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_12_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf12":
+ """Create InterpolationMethodOneOf12 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf12Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf12Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of13_stub.py b/test/types/interpolation_method_one_of13_stub.py
new file mode 100644
index 0000000..fadd44a
--- /dev/null
+++ b/test/types/interpolation_method_one_of13_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of13 import (
+ InterpolationMethodOneOf13,
+ )
+
+ InterpolationMethodOneOf13Adapter = TypeAdapter(InterpolationMethodOneOf13)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_13_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Interpolate with a non-smoothing spline of order 2, called Akima interpolation.",
+ "enum" : [ "akima" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_13_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_13_faker = JSF(
+ interpolation_method_one_of_13_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf13Stub:
+ """InterpolationMethodOneOf13 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_13_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf13":
+ """Create InterpolationMethodOneOf13 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf13Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf13Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of1_stub.py b/test/types/interpolation_method_one_of1_stub.py
new file mode 100644
index 0000000..d36706d
--- /dev/null
+++ b/test/types/interpolation_method_one_of1_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of1 import (
+ InterpolationMethodOneOf1,
+ )
+
+ InterpolationMethodOneOf1Adapter = TypeAdapter(InterpolationMethodOneOf1)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_1_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Interpolate with a fixed, user-specified value. This method also extrapolates.",
+ "enum" : [ "fixed" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_1_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_1_faker = JSF(
+ interpolation_method_one_of_1_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf1Stub:
+ """InterpolationMethodOneOf1 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_1_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf1":
+ """Create InterpolationMethodOneOf1 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf1Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf1Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of2_stub.py b/test/types/interpolation_method_one_of2_stub.py
new file mode 100644
index 0000000..9caefdb
--- /dev/null
+++ b/test/types/interpolation_method_one_of2_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of2 import (
+ InterpolationMethodOneOf2,
+ )
+
+ InterpolationMethodOneOf2Adapter = TypeAdapter(InterpolationMethodOneOf2)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_2_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Same as pad, but using the last observed value. This method also extrapolates",
+ "enum" : [ "backfill" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_2_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_2_faker = JSF(
+ interpolation_method_one_of_2_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf2Stub:
+ """InterpolationMethodOneOf2 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_2_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf2":
+ """Create InterpolationMethodOneOf2 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf2Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf2Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of3_stub.py b/test/types/interpolation_method_one_of3_stub.py
new file mode 100644
index 0000000..4cff7b1
--- /dev/null
+++ b/test/types/interpolation_method_one_of3_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of3 import (
+ InterpolationMethodOneOf3,
+ )
+
+ InterpolationMethodOneOf3Adapter = TypeAdapter(InterpolationMethodOneOf3)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_3_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Linearly go from the first observed value of the gap to the last observed oneThis method also extrapolates",
+ "enum" : [ "linear" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_3_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_3_faker = JSF(
+ interpolation_method_one_of_3_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf3Stub:
+ """InterpolationMethodOneOf3 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_3_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf3":
+ """Create InterpolationMethodOneOf3 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf3Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf3Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of4_stub.py b/test/types/interpolation_method_one_of4_stub.py
new file mode 100644
index 0000000..b667c57
--- /dev/null
+++ b/test/types/interpolation_method_one_of4_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of4 import (
+ InterpolationMethodOneOf4,
+ )
+
+ InterpolationMethodOneOf4Adapter = TypeAdapter(InterpolationMethodOneOf4)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_4_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Use the value that is closest in time.",
+ "enum" : [ "nearest" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_4_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_4_faker = JSF(
+ interpolation_method_one_of_4_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf4Stub:
+ """InterpolationMethodOneOf4 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_4_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf4":
+ """Create InterpolationMethodOneOf4 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf4Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf4Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of5_stub.py b/test/types/interpolation_method_one_of5_stub.py
new file mode 100644
index 0000000..487a46e
--- /dev/null
+++ b/test/types/interpolation_method_one_of5_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of5 import (
+ InterpolationMethodOneOf5,
+ )
+
+ InterpolationMethodOneOf5Adapter = TypeAdapter(InterpolationMethodOneOf5)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_5_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Interpolate with a spline function of order 0, which is a piecewise polynomial.",
+ "enum" : [ "zero" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_5_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_5_faker = JSF(
+ interpolation_method_one_of_5_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf5Stub:
+ """InterpolationMethodOneOf5 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_5_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf5":
+ """Create InterpolationMethodOneOf5 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf5Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf5Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of6_stub.py b/test/types/interpolation_method_one_of6_stub.py
new file mode 100644
index 0000000..8f9a186
--- /dev/null
+++ b/test/types/interpolation_method_one_of6_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of6 import (
+ InterpolationMethodOneOf6,
+ )
+
+ InterpolationMethodOneOf6Adapter = TypeAdapter(InterpolationMethodOneOf6)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_6_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Interpolate with a spline function of order 1, which is a piecewise polynomial.",
+ "enum" : [ "slinear" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_6_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_6_faker = JSF(
+ interpolation_method_one_of_6_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf6Stub:
+ """InterpolationMethodOneOf6 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_6_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf6":
+ """Create InterpolationMethodOneOf6 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf6Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf6Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of7_stub.py b/test/types/interpolation_method_one_of7_stub.py
new file mode 100644
index 0000000..48653d1
--- /dev/null
+++ b/test/types/interpolation_method_one_of7_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of7 import (
+ InterpolationMethodOneOf7,
+ )
+
+ InterpolationMethodOneOf7Adapter = TypeAdapter(InterpolationMethodOneOf7)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_7_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Interpolate with a spline function of order 2, which is a piecewise polynomial.",
+ "enum" : [ "quadratic" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_7_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_7_faker = JSF(
+ interpolation_method_one_of_7_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf7Stub:
+ """InterpolationMethodOneOf7 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_7_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf7":
+ """Create InterpolationMethodOneOf7 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf7Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf7Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of8_stub.py b/test/types/interpolation_method_one_of8_stub.py
new file mode 100644
index 0000000..6c1c7c4
--- /dev/null
+++ b/test/types/interpolation_method_one_of8_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of8 import (
+ InterpolationMethodOneOf8,
+ )
+
+ InterpolationMethodOneOf8Adapter = TypeAdapter(InterpolationMethodOneOf8)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_8_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Interpolate with a spline function of order 3, which is a piecewise polynomial.",
+ "enum" : [ "cubic" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_8_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_8_faker = JSF(
+ interpolation_method_one_of_8_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf8Stub:
+ """InterpolationMethodOneOf8 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_8_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf8":
+ """Create InterpolationMethodOneOf8 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf8Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf8Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of9_stub.py b/test/types/interpolation_method_one_of9_stub.py
new file mode 100644
index 0000000..a8fd7d8
--- /dev/null
+++ b/test/types/interpolation_method_one_of9_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of9 import (
+ InterpolationMethodOneOf9,
+ )
+
+ InterpolationMethodOneOf9Adapter = TypeAdapter(InterpolationMethodOneOf9)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_9_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Interpolate with a polynomial of the lowest possible degree passing trough the data points.",
+ "enum" : [ "polynomial" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_9_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_9_faker = JSF(
+ interpolation_method_one_of_9_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOf9Stub:
+ """InterpolationMethodOneOf9 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_9_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf9":
+ """Create InterpolationMethodOneOf9 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOf9Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOf9Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_one_of_stub.py b/test/types/interpolation_method_one_of_stub.py
new file mode 100644
index 0000000..5b8da57
--- /dev/null
+++ b/test/types/interpolation_method_one_of_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method_one_of import (
+ InterpolationMethodOneOf,
+ )
+
+ InterpolationMethodOneOfAdapter = TypeAdapter(InterpolationMethodOneOf)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_one_of_model_schema = json.loads(
+ r"""{
+ "type" : "string",
+ "description" : "Interpolate with the value of the first observed point. This method also extrapolates.",
+ "enum" : [ "pad" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_one_of_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_one_of_faker = JSF(
+ interpolation_method_one_of_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodOneOfStub:
+ """InterpolationMethodOneOf unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_one_of_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethodOneOf":
+ """Create InterpolationMethodOneOf stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodOneOfAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodOneOfAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_method_stub.py b/test/types/interpolation_method_stub.py
new file mode 100644
index 0000000..9d44b8f
--- /dev/null
+++ b/test/types/interpolation_method_stub.py
@@ -0,0 +1,92 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_method import InterpolationMethod
+
+ InterpolationMethodAdapter = TypeAdapter(InterpolationMethod)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_method_model_schema = json.loads(
+ r"""{
+ "title" : "Interpolation method",
+ "type" : "string",
+ "oneOf" : [ {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_1"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_2"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_3"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_4"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_5"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_6"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_7"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_8"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_9"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_10"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_11"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_12"
+ }, {
+ "$ref" : "#/components/schemas/Interpolation_method_oneOf_13"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_method_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_method_faker = JSF(
+ interpolation_method_model_schema, allow_none_optionals=1
+)
+
+
+class InterpolationMethodStub:
+ """InterpolationMethod unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_method_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationMethod":
+ """Create InterpolationMethod stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationMethodAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationMethodAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_spec_stub.py b/test/types/interpolation_spec_stub.py
new file mode 100644
index 0000000..a874323
--- /dev/null
+++ b/test/types/interpolation_spec_stub.py
@@ -0,0 +1,78 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation_spec import InterpolationSpec
+
+ InterpolationSpecAdapter = TypeAdapter(InterpolationSpec)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_spec_model_schema = json.loads(
+ r"""{
+ "required" : [ "method" ],
+ "type" : "object",
+ "properties" : {
+ "method" : {
+ "$ref" : "#/components/schemas/Interpolation_method"
+ },
+ "value" : {
+ "title" : "Interpolation parameter",
+ "type" : "integer",
+ "description" : "Optional parameter value for the interpolation method (see method description)."
+ },
+ "order" : {
+ "title" : "Interpolation order",
+ "type" : "integer",
+ "description" : "Optional order parameter for the interpolation method (see method description)."
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Defines whether, and how to treat missing values.\n\nThis can occur in two circumstances when aggregating (setting a sample frequency):\n* missing values: if there are missing (or invalid) values stored for\na given freq-interval,\n\"interpolation\" specifies how to compute these.\n* down-sampling: when the specified freq is smaller than the series’\nactual frequency.\n\"interpolation\" specifies how to compute intermediate values."
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_spec_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_spec_faker = JSF(interpolation_spec_model_schema, allow_none_optionals=1)
+
+
+class InterpolationSpecStub:
+ """InterpolationSpec unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_spec_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "InterpolationSpec":
+ """Create InterpolationSpec stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationSpecAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationSpecAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/interpolation_stub.py b/test/types/interpolation_stub.py
new file mode 100644
index 0000000..7ff4667
--- /dev/null
+++ b/test/types/interpolation_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.interpolation import Interpolation
+
+ InterpolationAdapter = TypeAdapter(Interpolation)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+interpolation_model_schema = json.loads(
+ r"""{
+ "title" : "Interpolation",
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/InterpolationMethod"
+ }, {
+ "$ref" : "#/components/schemas/InterpolationSpec"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+interpolation_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+interpolation_faker = JSF(interpolation_model_schema, allow_none_optionals=1)
+
+
+class InterpolationStub:
+ """Interpolation unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return interpolation_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "Interpolation":
+ """Create Interpolation stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ InterpolationAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return InterpolationAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/links_stub.py b/test/types/links_stub.py
new file mode 100644
index 0000000..a1760fb
--- /dev/null
+++ b/test/types/links_stub.py
@@ -0,0 +1,64 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.links import Links
+
+ LinksAdapter = TypeAdapter(Links)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+links_model_schema = json.loads(
+ r"""{
+ "title" : "_Links",
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/HALLink"
+ }, {
+ "type" : "array",
+ "items" : {
+ "$ref" : "#/components/schemas/HALLink"
+ }
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+links_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+links_faker = JSF(links_model_schema, allow_none_optionals=1)
+
+
+class LinksStub:
+ """Links unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return links_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "Links":
+ """Create Links stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(LinksAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return LinksAdapter.validate_python(json, context={"skip_validation": True})
diff --git a/test/types/location_inner_stub.py b/test/types/location_inner_stub.py
new file mode 100644
index 0000000..21fcb7d
--- /dev/null
+++ b/test/types/location_inner_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.location_inner import LocationInner
+
+ LocationInnerAdapter = TypeAdapter(LocationInner)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+location_inner_model_schema = json.loads(
+ r"""{
+ "title" : "Location_inner",
+ "anyOf" : [ {
+ "type" : "string"
+ }, {
+ "type" : "integer"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+location_inner_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+location_inner_faker = JSF(location_inner_model_schema, allow_none_optionals=1)
+
+
+class LocationInnerStub:
+ """LocationInner unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return location_inner_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "LocationInner":
+ """Create LocationInner stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ LocationInnerAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return LocationInnerAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/message_arguments_stub.py b/test/types/message_arguments_stub.py
new file mode 100644
index 0000000..f745ad1
--- /dev/null
+++ b/test/types/message_arguments_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.message_arguments import MessageArguments
+
+ MessageArgumentsAdapter = TypeAdapter(MessageArguments)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+message_arguments_model_schema = json.loads(
+ r"""{
+ "title" : "Message Arguments",
+ "anyOf" : [ {
+ "type" : "string"
+ }, {
+ "$ref" : "#/components/schemas/MessageProperties"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+message_arguments_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+message_arguments_faker = JSF(message_arguments_model_schema, allow_none_optionals=1)
+
+
+class MessageArgumentsStub:
+ """MessageArguments unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return message_arguments_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "MessageArguments":
+ """Create MessageArguments stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ MessageArgumentsAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return MessageArgumentsAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/message_level_stub.py b/test/types/message_level_stub.py
new file mode 100644
index 0000000..b76b5cc
--- /dev/null
+++ b/test/types/message_level_stub.py
@@ -0,0 +1,63 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.message_level import MessageLevel
+
+ MessageLevelAdapter = TypeAdapter(MessageLevel)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+message_level_model_schema = json.loads(
+ r"""{
+ "title" : "Message_level",
+ "type" : "string",
+ "default" : "info",
+ "enum" : [ "debug", "info", "warning", "error", "fatal" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+message_level_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+message_level_faker = JSF(message_level_model_schema, allow_none_optionals=1)
+
+
+class MessageLevelStub:
+ """MessageLevel unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return message_level_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "MessageLevel":
+ """Create MessageLevel stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ MessageLevelAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return MessageLevelAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/message_properties_stub.py b/test/types/message_properties_stub.py
new file mode 100644
index 0000000..bd8d231
--- /dev/null
+++ b/test/types/message_properties_stub.py
@@ -0,0 +1,72 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.message_properties import MessageProperties
+
+ MessagePropertiesAdapter = TypeAdapter(MessageProperties)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+message_properties_model_schema = json.loads(
+ r"""{
+ "type" : "object",
+ "properties" : {
+ "resource" : {
+ "title" : "Series resource id",
+ "type" : "string"
+ },
+ "metric" : {
+ "title" : "Series metric",
+ "type" : "string"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Additional message arguments."
+}
+""",
+ object_hook=with_example_provider,
+)
+message_properties_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+message_properties_faker = JSF(message_properties_model_schema, allow_none_optionals=1)
+
+
+class MessagePropertiesStub:
+ """MessageProperties unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return message_properties_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "MessageProperties":
+ """Create MessageProperties stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ MessagePropertiesAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return MessagePropertiesAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/message_stub.py b/test/types/message_stub.py
new file mode 100644
index 0000000..305c968
--- /dev/null
+++ b/test/types/message_stub.py
@@ -0,0 +1,78 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.message import Message
+
+ MessageAdapter = TypeAdapter(Message)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+message_model_schema = json.loads(
+ r"""{
+ "title" : "Message",
+ "required" : [ "message" ],
+ "type" : "object",
+ "properties" : {
+ "code" : {
+ "title" : "code",
+ "type" : "string",
+ "nullable" : true
+ },
+ "message" : {
+ "title" : "Message",
+ "type" : "string"
+ },
+ "level" : {
+ "$ref" : "#/components/schemas/Message_level"
+ },
+ "args" : {
+ "title" : "args",
+ "type" : "object",
+ "nullable" : true
+ }
+ },
+ "description" : "Individual (info/warning/error) message in a response."
+}
+""",
+ object_hook=with_example_provider,
+)
+message_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+message_faker = JSF(message_model_schema, allow_none_optionals=1)
+
+
+class MessageStub:
+ """Message unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return message_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "Message":
+ """Create Message stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(MessageAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return MessageAdapter.validate_python(json, context={"skip_validation": True})
diff --git a/test/types/object_data_set_stub.py b/test/types/object_data_set_stub.py
new file mode 100644
index 0000000..ee88b87
--- /dev/null
+++ b/test/types/object_data_set_stub.py
@@ -0,0 +1,78 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.object_data_set import ObjectDataSet
+
+ ObjectDataSetAdapter = TypeAdapter(ObjectDataSet)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+object_data_set_model_schema = json.loads(
+ r"""{
+ "required" : [ "data" ],
+ "type" : "object",
+ "properties" : {
+ "attributes" : {
+ "$ref" : "#/components/schemas/DataSetAttributes"
+ },
+ "window_spec" : {
+ "$ref" : "#/components/schemas/DataSetWindow"
+ },
+ "data" : {
+ "title" : "Data",
+ "type" : "array",
+ "items" : {
+ "$ref" : "#/components/schemas/ObjectData"
+ }
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Data result in object format.\n\nResult item when render option `render.header_array` is not set.\n\nThe data values are keyed by their attributes (`resource`, `metric`, `aggregation`),\naccording to the render options:\n* _hierachical_: for each level, a sub-object is created\n (e.g. `render.mode=hier_dict`)\n* _flattened_: the attributes are '.'-separated concatenation\n of the attributes (e.g `render.mode=flat_dict`)\n* _mixed_: (.e.g. `render.mode=metric_flat_dict`) a single level\n (e.g. `metric`) is used as main key, any remaining levels\n (`resource`,`aggregation`) are indicated with a flattened subkey.\n\nWhen `render.rollup=true`, the attribute levels that are the same for all series are\nnot used as key, but reported as a data or table attribute."
+}
+""",
+ object_hook=with_example_provider,
+)
+object_data_set_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+object_data_set_faker = JSF(object_data_set_model_schema, allow_none_optionals=1)
+
+
+class ObjectDataSetStub:
+ """ObjectDataSet unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return object_data_set_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "ObjectDataSet":
+ """Create ObjectDataSet stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ ObjectDataSetAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return ObjectDataSetAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/object_data_stub.py b/test/types/object_data_stub.py
new file mode 100644
index 0000000..c905491
--- /dev/null
+++ b/test/types/object_data_stub.py
@@ -0,0 +1,98 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.object_data import ObjectData
+
+ ObjectDataAdapter = TypeAdapter(ObjectData)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+object_data_model_schema = json.loads(
+ r"""{
+ "required" : [ "timestamp" ],
+ "type" : "object",
+ "properties" : {
+ "timestamp" : {
+ "$ref" : "#/components/schemas/Timestamp"
+ },
+ "timestamp_iso" : {
+ "$ref" : "#/components/schemas/TimestampIso"
+ },
+ "role" : {
+ "$ref" : "#/components/schemas/Role"
+ },
+ "resource" : {
+ "title" : "Resource",
+ "type" : "string",
+ "description" : "Series resource id, if applicable for all values."
+ },
+ "metric" : {
+ "title" : "Metric",
+ "type" : "string",
+ "description" : "Series metric, if applicable for all values."
+ },
+ "aggregation" : {
+ "title" : "Aggregation",
+ "type" : "string",
+ "description" : "Series aggregation, if applicable for all values."
+ },
+ "levels" : {
+ "title" : "Hierarchical Levels",
+ "type" : "array",
+ "description" : "Attribute level names used to key the values for this observation.\n\nLevels that are flattened have a dot-separated key.\n\nIf all observations have the same attribute for a level, that level might be omitted.",
+ "example" : [ "resource", "metric", "aggregation" ],
+ "items" : {
+ "type" : "string"
+ }
+ }
+ },
+ "additionalProperties" : {
+ "$ref" : "#/components/schemas/ObjectData_value"
+ },
+ "description" : "Result data for a timestamp in object format."
+}
+""",
+ object_hook=with_example_provider,
+)
+object_data_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+object_data_faker = JSF(object_data_model_schema, allow_none_optionals=1)
+
+
+class ObjectDataStub:
+ """ObjectData unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return object_data_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "ObjectData":
+ """Create ObjectData stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(ObjectDataAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return ObjectDataAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/object_data_value_stub.py b/test/types/object_data_value_stub.py
new file mode 100644
index 0000000..a260eed
--- /dev/null
+++ b/test/types/object_data_value_stub.py
@@ -0,0 +1,67 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.object_data_value import ObjectDataValue
+
+ ObjectDataValueAdapter = TypeAdapter(ObjectDataValue)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+object_data_value_model_schema = json.loads(
+ r"""{
+ "title" : "Data ",
+ "oneOf" : [ {
+ "title" : "Hierarchical Data",
+ "type" : "object",
+ "description" : "Values for the series whose attributes corresponds with the key. Keyed by sub-levels."
+ }, {
+ "$ref" : "#/components/schemas/Datum"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+object_data_value_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+object_data_value_faker = JSF(object_data_value_model_schema, allow_none_optionals=1)
+
+
+class ObjectDataValueStub:
+ """ObjectDataValue unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return object_data_value_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "ObjectDataValue":
+ """Create ObjectDataValue stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ ObjectDataValueAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return ObjectDataValueAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/queries_list_response_stub.py b/test/types/queries_list_response_stub.py
new file mode 100644
index 0000000..9d33b9d
--- /dev/null
+++ b/test/types/queries_list_response_stub.py
@@ -0,0 +1,107 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.queries_list_response import QueriesListResponse
+
+ QueriesListResponseAdapter = TypeAdapter(QueriesListResponse)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+queries_list_response_model_schema = json.loads(
+ r"""{
+ "required" : [ "_links", "count", "limit", "offset", "queries" ],
+ "type" : "object",
+ "properties" : {
+ "messages" : {
+ "title" : "Messages",
+ "type" : "array",
+ "items" : {
+ "$ref" : "#/components/schemas/Message"
+ }
+ },
+ "queries" : {
+ "title" : "Query item list",
+ "type" : "array",
+ "description" : "One page of matching query definitions.",
+ "items" : {
+ "$ref" : "#/components/schemas/QueryListItem"
+ }
+ },
+ "count" : {
+ "title" : "Current page size",
+ "type" : "integer",
+ "description" : "Number of query definitions returned in the current response."
+ },
+ "offset" : {
+ "title" : "Page offset",
+ "type" : "integer",
+ "description" : "Offset in the full listing (skipped definitions)."
+ },
+ "limit" : {
+ "title" : "Page size limit",
+ "type" : "integer",
+ "description" : "Maximal number of query definitions returned in one response."
+ },
+ "total_count" : {
+ "title" : "Total count",
+ "type" : "integer",
+ "description" : "Total number of query definitions matching the filter."
+ },
+ "_links" : {
+ "$ref" : "#/components/schemas/QueryListHALLinks"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Listing of named queries, with paging links."
+}
+""",
+ object_hook=with_example_provider,
+)
+queries_list_response_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+queries_list_response_faker = JSF(
+ queries_list_response_model_schema, allow_none_optionals=1
+)
+
+
+class QueriesListResponseStub:
+ """QueriesListResponse unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return queries_list_response_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "QueriesListResponse":
+ """Create QueriesListResponse stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ QueriesListResponseAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueriesListResponseAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_definition_stub.py b/test/types/query_definition_stub.py
new file mode 100644
index 0000000..00e58a9
--- /dev/null
+++ b/test/types/query_definition_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_definition import QueryDefinition
+
+ QueryDefinitionAdapter = TypeAdapter(QueryDefinition)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_definition_model_schema = json.loads(
+ r"""{
+ "title" : "Query Definition",
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/QueryUpdateInput"
+ }, {
+ "$ref" : "#/components/schemas/Query-Input"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+query_definition_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_definition_faker = JSF(query_definition_model_schema, allow_none_optionals=1)
+
+
+class QueryDefinitionStub:
+ """QueryDefinition unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_definition_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "QueryDefinition":
+ """Create QueryDefinition stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ QueryDefinitionAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryDefinitionAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_entity_input_stub.py b/test/types/query_entity_input_stub.py
new file mode 100644
index 0000000..96a2b21
--- /dev/null
+++ b/test/types/query_entity_input_stub.py
@@ -0,0 +1,78 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_entity_input import QueryEntityInput
+
+ QueryEntityInputAdapter = TypeAdapter(QueryEntityInput)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_entity_input_model_schema = json.loads(
+ r"""{
+ "required" : [ "name", "query" ],
+ "type" : "object",
+ "properties" : {
+ "name" : {
+ "title" : "Query name",
+ "type" : "string",
+ "description" : "Name of the stored query definition."
+ },
+ "meta" : {
+ "title" : "Query metadata",
+ "type" : "object",
+ "description" : "User metadata for the query definition."
+ },
+ "query" : {
+ "$ref" : "#/components/schemas/Query-Input"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Input data to create a query definition."
+}
+""",
+ object_hook=with_example_provider,
+)
+query_entity_input_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_entity_input_faker = JSF(query_entity_input_model_schema, allow_none_optionals=1)
+
+
+class QueryEntityInputStub:
+ """QueryEntityInput unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_entity_input_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "QueryEntityInput":
+ """Create QueryEntityInput stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ QueryEntityInputAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryEntityInputAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_execution_message_level_stub.py b/test/types/query_execution_message_level_stub.py
new file mode 100644
index 0000000..0645514
--- /dev/null
+++ b/test/types/query_execution_message_level_stub.py
@@ -0,0 +1,68 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_execution_message_level import (
+ QueryExecutionMessageLevel,
+ )
+
+ QueryExecutionMessageLevelAdapter = TypeAdapter(QueryExecutionMessageLevel)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_execution_message_level_model_schema = json.loads(
+ r"""{
+ "title" : "QueryExecutionMessage_level",
+ "type" : "string",
+ "enum" : [ "debug", "info", "warning", "error" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+query_execution_message_level_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_execution_message_level_faker = JSF(
+ query_execution_message_level_model_schema, allow_none_optionals=1
+)
+
+
+class QueryExecutionMessageLevelStub:
+ """QueryExecutionMessageLevel unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_execution_message_level_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "QueryExecutionMessageLevel":
+ """Create QueryExecutionMessageLevel stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ QueryExecutionMessageLevelAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryExecutionMessageLevelAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_execution_message_stub.py b/test/types/query_execution_message_stub.py
new file mode 100644
index 0000000..e3aa654
--- /dev/null
+++ b/test/types/query_execution_message_stub.py
@@ -0,0 +1,101 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_execution_message import (
+ QueryExecutionMessage,
+ )
+
+ QueryExecutionMessageAdapter = TypeAdapter(QueryExecutionMessage)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_execution_message_model_schema = json.loads(
+ r"""{
+ "required" : [ "action", "category", "level", "message", "timestamp" ],
+ "type" : "object",
+ "properties" : {
+ "message" : {
+ "title" : "Message",
+ "type" : "string",
+ "description" : "A human readable message."
+ },
+ "level" : {
+ "$ref" : "#/components/schemas/QueryExecutionMessage_level"
+ },
+ "timestamp" : {
+ "title" : "Timestamp",
+ "type" : "string",
+ "format" : "date-time"
+ },
+ "action" : {
+ "title" : "Action",
+ "type" : "string",
+ "description" : "The request action that caused this message."
+ },
+ "category" : {
+ "title" : "Message Category",
+ "type" : "string",
+ "description" : "The subsystem that issued this message.",
+ "example" : "data"
+ },
+ "properties" : {
+ "$ref" : "#/components/schemas/Message_Arguments"
+ },
+ "exception" : {
+ "$ref" : "#/components/schemas/CauseException"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "A message object that informs or warns about a query execution issue."
+}
+""",
+ object_hook=with_example_provider,
+)
+query_execution_message_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_execution_message_faker = JSF(
+ query_execution_message_model_schema, allow_none_optionals=1
+)
+
+
+class QueryExecutionMessageStub:
+ """QueryExecutionMessage unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_execution_message_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "QueryExecutionMessage":
+ """Create QueryExecutionMessage stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ QueryExecutionMessageAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryExecutionMessageAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_hal_links_stub.py b/test/types/query_hal_links_stub.py
new file mode 100644
index 0000000..dcbdb4c
--- /dev/null
+++ b/test/types/query_hal_links_stub.py
@@ -0,0 +1,71 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_hal_links import QueryHALLinks
+
+ QueryHALLinksAdapter = TypeAdapter(QueryHALLinks)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_hal_links_model_schema = json.loads(
+ r"""{
+ "required" : [ "execute", "self" ],
+ "type" : "object",
+ "properties" : {
+ "self" : {
+ "$ref" : "#/components/schemas/HALLink"
+ },
+ "execute" : {
+ "$ref" : "#/components/schemas/HALLink"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "HAL Links for a query entity."
+}
+""",
+ object_hook=with_example_provider,
+)
+query_hal_links_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_hal_links_faker = JSF(query_hal_links_model_schema, allow_none_optionals=1)
+
+
+class QueryHALLinksStub:
+ """QueryHALLinks unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_hal_links_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "QueryHALLinks":
+ """Create QueryHALLinks stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ QueryHALLinksAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryHALLinksAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_input_stub.py b/test/types/query_input_stub.py
new file mode 100644
index 0000000..d148a11
--- /dev/null
+++ b/test/types/query_input_stub.py
@@ -0,0 +1,109 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_input import QueryInput
+
+ QueryInputAdapter = TypeAdapter(QueryInput)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_input_model_schema = json.loads(
+ r"""{
+ "type" : "object",
+ "properties" : {
+ "resource" : {
+ "title" : "Default Resource",
+ "type" : "string",
+ "description" : "Default resource for the series in the query."
+ },
+ "metric" : {
+ "title" : "Default Metric",
+ "type" : "string",
+ "description" : "Default metric for the series in the query."
+ },
+ "aggregation" : {
+ "$ref" : "#/components/schemas/Default_Aggregation"
+ },
+ "interpolation" : {
+ "$ref" : "#/components/schemas/Default_Interpolation"
+ },
+ "freq" : {
+ "$ref" : "#/components/schemas/Grouping_interval"
+ },
+ "from" : {
+ "$ref" : "#/components/schemas/Time_Window_From"
+ },
+ "until" : {
+ "$ref" : "#/components/schemas/Time_Window_Until"
+ },
+ "window" : {
+ "$ref" : "#/components/schemas/Window"
+ },
+ "periods" : {
+ "title" : "Periods",
+ "type" : "integer",
+ "description" : "The size of the time window in number of `freq` units. One of the [time line](https://docs.waylay.io/#/api/query/?id=time-line-properties) specifiers."
+ },
+ "align" : {
+ "$ref" : "#/components/schemas/Alignment"
+ },
+ "data" : {
+ "title" : "Series specifications",
+ "type" : "array",
+ "description" : "List of series specifications. When not specified, a single default series specification is assumed(`[{}]`, using the default `metric`,`resource`, ... ).",
+ "items" : {
+ "$ref" : "#/components/schemas/SeriesSpec"
+ }
+ },
+ "render" : {
+ "$ref" : "#/components/schemas/Render"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Query definition for a Waylay analytics query.\n\nSee also [api docs](https://docs.waylay.io/#/api/query/?id=data-query-json-representation)."
+}
+""",
+ object_hook=with_example_provider,
+)
+query_input_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_input_faker = JSF(query_input_model_schema, allow_none_optionals=1)
+
+
+class QueryInputStub:
+ """QueryInput unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_input_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "QueryInput":
+ """Create QueryInput stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(QueryInputAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryInputAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_list_hal_links_stub.py b/test/types/query_list_hal_links_stub.py
new file mode 100644
index 0000000..36aa88a
--- /dev/null
+++ b/test/types/query_list_hal_links_stub.py
@@ -0,0 +1,83 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_list_hal_links import QueryListHALLinks
+
+ QueryListHALLinksAdapter = TypeAdapter(QueryListHALLinks)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_list_hal_links_model_schema = json.loads(
+ r"""{
+ "title" : "QueryListHALLinks",
+ "required" : [ "self" ],
+ "type" : "object",
+ "properties" : {
+ "self" : {
+ "$ref" : "#/components/schemas/HALLink"
+ },
+ "first" : {
+ "$ref" : "#/components/schemas/HALLink"
+ },
+ "prev" : {
+ "$ref" : "#/components/schemas/HALLink"
+ },
+ "next" : {
+ "$ref" : "#/components/schemas/HALLink"
+ },
+ "last" : {
+ "$ref" : "#/components/schemas/HALLink"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "HAL Links for a query entity."
+}
+""",
+ object_hook=with_example_provider,
+)
+query_list_hal_links_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_list_hal_links_faker = JSF(
+ query_list_hal_links_model_schema, allow_none_optionals=1
+)
+
+
+class QueryListHALLinksStub:
+ """QueryListHALLinks unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_list_hal_links_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "QueryListHALLinks":
+ """Create QueryListHALLinks stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ QueryListHALLinksAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryListHALLinksAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_list_item_stub.py b/test/types/query_list_item_stub.py
new file mode 100644
index 0000000..bb4f070
--- /dev/null
+++ b/test/types/query_list_item_stub.py
@@ -0,0 +1,84 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_list_item import QueryListItem
+
+ QueryListItemAdapter = TypeAdapter(QueryListItem)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_list_item_model_schema = json.loads(
+ r"""{
+ "title" : "QueryListItem",
+ "required" : [ "_links", "attrs", "name" ],
+ "type" : "object",
+ "properties" : {
+ "_links" : {
+ "$ref" : "#/components/schemas/QueryHALLinks"
+ },
+ "attrs" : {
+ "title" : "Query attributes",
+ "type" : "object",
+ "description" : "System provided metadata for the query definition."
+ },
+ "name" : {
+ "title" : "Query name",
+ "type" : "string",
+ "description" : "Name of the stored query definition."
+ },
+ "meta" : {
+ "title" : "Query metadata",
+ "type" : "object",
+ "description" : "User metadata for the query definition."
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Listing of a query definition item."
+}
+""",
+ object_hook=with_example_provider,
+)
+query_list_item_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_list_item_faker = JSF(query_list_item_model_schema, allow_none_optionals=1)
+
+
+class QueryListItemStub:
+ """QueryListItem unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_list_item_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "QueryListItem":
+ """Create QueryListItem stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ QueryListItemAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryListItemAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_output_stub.py b/test/types/query_output_stub.py
new file mode 100644
index 0000000..7ac72d2
--- /dev/null
+++ b/test/types/query_output_stub.py
@@ -0,0 +1,109 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_output import QueryOutput
+
+ QueryOutputAdapter = TypeAdapter(QueryOutput)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_output_model_schema = json.loads(
+ r"""{
+ "type" : "object",
+ "properties" : {
+ "resource" : {
+ "title" : "Default Resource",
+ "type" : "string",
+ "description" : "Default resource for the series in the query."
+ },
+ "metric" : {
+ "title" : "Default Metric",
+ "type" : "string",
+ "description" : "Default metric for the series in the query."
+ },
+ "aggregation" : {
+ "$ref" : "#/components/schemas/Default_Aggregation"
+ },
+ "interpolation" : {
+ "$ref" : "#/components/schemas/Default_Interpolation"
+ },
+ "freq" : {
+ "$ref" : "#/components/schemas/Grouping_interval"
+ },
+ "from" : {
+ "$ref" : "#/components/schemas/Time_Window_From"
+ },
+ "until" : {
+ "$ref" : "#/components/schemas/Time_Window_Until"
+ },
+ "window" : {
+ "$ref" : "#/components/schemas/Window"
+ },
+ "periods" : {
+ "title" : "Periods",
+ "type" : "integer",
+ "description" : "The size of the time window in number of `freq` units. One of the [time line](https://docs.waylay.io/#/api/query/?id=time-line-properties) specifiers."
+ },
+ "align" : {
+ "$ref" : "#/components/schemas/Alignment"
+ },
+ "data" : {
+ "title" : "Series specifications",
+ "type" : "array",
+ "description" : "List of series specifications. When not specified, a single default series specification is assumed(`[{}]`, using the default `metric`,`resource`, ... ).",
+ "items" : {
+ "$ref" : "#/components/schemas/SeriesSpec"
+ }
+ },
+ "render" : {
+ "$ref" : "#/components/schemas/Render"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Query definition for a Waylay analytics query.\n\nSee also [api docs](https://docs.waylay.io/#/api/query/?id=data-query-json-representation)."
+}
+""",
+ object_hook=with_example_provider,
+)
+query_output_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_output_faker = JSF(query_output_model_schema, allow_none_optionals=1)
+
+
+class QueryOutputStub:
+ """QueryOutput unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_output_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "QueryOutput":
+ """Create QueryOutput stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(QueryOutputAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryOutputAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_response_stub.py b/test/types/query_response_stub.py
new file mode 100644
index 0000000..3069839
--- /dev/null
+++ b/test/types/query_response_stub.py
@@ -0,0 +1,93 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_response import QueryResponse
+
+ QueryResponseAdapter = TypeAdapter(QueryResponse)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_response_model_schema = json.loads(
+ r"""{
+ "required" : [ "_links", "attrs", "name", "query" ],
+ "type" : "object",
+ "properties" : {
+ "_links" : {
+ "$ref" : "#/components/schemas/QueryHALLinks"
+ },
+ "attrs" : {
+ "title" : "Query attributes",
+ "type" : "object",
+ "description" : "System provided metadata for the query definition."
+ },
+ "name" : {
+ "title" : "Query name",
+ "type" : "string",
+ "description" : "Name of the stored query definition."
+ },
+ "meta" : {
+ "title" : "Query metadata",
+ "type" : "object",
+ "description" : "User metadata for the query definition."
+ },
+ "query" : {
+ "$ref" : "#/components/schemas/Query-Output"
+ },
+ "messages" : {
+ "title" : "Messages",
+ "type" : "array",
+ "items" : {
+ "$ref" : "#/components/schemas/Message"
+ }
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Represents a single named query."
+}
+""",
+ object_hook=with_example_provider,
+)
+query_response_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_response_faker = JSF(query_response_model_schema, allow_none_optionals=1)
+
+
+class QueryResponseStub:
+ """QueryResponse unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_response_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "QueryResponse":
+ """Create QueryResponse stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ QueryResponseAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryResponseAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_result_stub.py b/test/types/query_result_stub.py
new file mode 100644
index 0000000..927e672
--- /dev/null
+++ b/test/types/query_result_stub.py
@@ -0,0 +1,89 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_result import QueryResult
+
+ QueryResultAdapter = TypeAdapter(QueryResult)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_result_model_schema = json.loads(
+ r"""{
+ "required" : [ "data", "messages", "query" ],
+ "type" : "object",
+ "properties" : {
+ "data" : {
+ "title" : "Response Data Sets",
+ "type" : "array",
+ "description" : "A list of data sets, each with their own time axis. There will be one dataset for each `role` specified in the query (by default a single `input` role).\n\nThe data is represented according to the `render` options in the query (default `COMPACT_WS`).",
+ "items" : {
+ "$ref" : "#/components/schemas/Response_Data_Set"
+ }
+ },
+ "query" : {
+ "$ref" : "#/components/schemas/Query-Input"
+ },
+ "messages" : {
+ "title" : "Messages and Warnings",
+ "type" : "array",
+ "items" : {
+ "$ref" : "#/components/schemas/QueryExecutionMessage"
+ }
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "A json data response.\n\nUses the format as specified by the\n`render` options of the request (defaults to `COMPACT_WS`).\n'",
+ "example" : {
+ "data" : [ ],
+ "query" : {
+ "resource" : "R",
+ "metric" : "temperature"
+ },
+ "messages" : [ ]
+ }
+}
+""",
+ object_hook=with_example_provider,
+)
+query_result_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_result_faker = JSF(query_result_model_schema, allow_none_optionals=1)
+
+
+class QueryResultStub:
+ """QueryResult unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_result_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "QueryResult":
+ """Create QueryResult stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(QueryResultAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryResultAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/query_update_input_stub.py b/test/types/query_update_input_stub.py
new file mode 100644
index 0000000..6388a1a
--- /dev/null
+++ b/test/types/query_update_input_stub.py
@@ -0,0 +1,72 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.query_update_input import QueryUpdateInput
+
+ QueryUpdateInputAdapter = TypeAdapter(QueryUpdateInput)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+query_update_input_model_schema = json.loads(
+ r"""{
+ "type" : "object",
+ "properties" : {
+ "meta" : {
+ "title" : "Query metadata",
+ "type" : "object",
+ "description" : "User metadata for the query definition."
+ },
+ "query" : {
+ "$ref" : "#/components/schemas/Query-Input"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Input data to update a query definition."
+}
+""",
+ object_hook=with_example_provider,
+)
+query_update_input_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+query_update_input_faker = JSF(query_update_input_model_schema, allow_none_optionals=1)
+
+
+class QueryUpdateInputStub:
+ """QueryUpdateInput unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return query_update_input_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "QueryUpdateInput":
+ """Create QueryUpdateInput stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ QueryUpdateInputAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return QueryUpdateInputAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render1_stub.py b/test/types/render1_stub.py
new file mode 100644
index 0000000..a68a152
--- /dev/null
+++ b/test/types/render1_stub.py
@@ -0,0 +1,61 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render1 import Render1
+
+ Render1Adapter = TypeAdapter(Render1)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_1_model_schema = json.loads(
+ r"""{
+ "title" : "Render",
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/_RenderMode"
+ }, {
+ "$ref" : "#/components/schemas/Render"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_1_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_1_faker = JSF(render_1_model_schema, allow_none_optionals=1)
+
+
+class Render1Stub:
+ """Render1 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_1_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "Render1":
+ """Create Render1 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(Render1Adapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return Render1Adapter.validate_python(json, context={"skip_validation": True})
diff --git a/test/types/render_mode_one_of1_stub.py b/test/types/render_mode_one_of1_stub.py
new file mode 100644
index 0000000..bb649e8
--- /dev/null
+++ b/test/types/render_mode_one_of1_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render_mode_one_of1 import RenderModeOneOf1
+
+ RenderModeOneOf1Adapter = TypeAdapter(RenderModeOneOf1)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_mode_one_of_1_model_schema = json.loads(
+ r"""{
+ "title" : "_RenderMode_oneOf_1",
+ "type" : "string",
+ "description" : "Render rows of timestamp and values. Show column headers.\n\n###### options\n- `iso_timestamp`: `False`\n- `header_array`: `row`\n- `roll_up`: `False`\n- `data_axis`: `column`",
+ "enum" : [ "COMPACT" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_mode_one_of_1_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_mode_one_of_1_faker = JSF(
+ render_mode_one_of_1_model_schema, allow_none_optionals=1
+)
+
+
+class RenderModeOneOf1Stub:
+ """RenderModeOneOf1 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_mode_one_of_1_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RenderModeOneOf1":
+ """Create RenderModeOneOf1 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RenderModeOneOf1Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderModeOneOf1Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render_mode_one_of2_stub.py b/test/types/render_mode_one_of2_stub.py
new file mode 100644
index 0000000..8d66ae4
--- /dev/null
+++ b/test/types/render_mode_one_of2_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render_mode_one_of2 import RenderModeOneOf2
+
+ RenderModeOneOf2Adapter = TypeAdapter(RenderModeOneOf2)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_mode_one_of_2_model_schema = json.loads(
+ r"""{
+ "title" : "_RenderMode_oneOf_2",
+ "type" : "string",
+ "description" : "Render rows of timestamp and values. Show column headers. Show the time window attributes.\n\n###### options\n- `iso_timestamp`: `False`\n- `header_array`: `row`\n- `roll_up`: `False`\n- `data_axis`: `column`\n- `include_window_spec`: `True`",
+ "enum" : [ "COMPACT_WS" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_mode_one_of_2_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_mode_one_of_2_faker = JSF(
+ render_mode_one_of_2_model_schema, allow_none_optionals=1
+)
+
+
+class RenderModeOneOf2Stub:
+ """RenderModeOneOf2 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_mode_one_of_2_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RenderModeOneOf2":
+ """Create RenderModeOneOf2 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RenderModeOneOf2Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderModeOneOf2Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render_mode_one_of3_stub.py b/test/types/render_mode_one_of3_stub.py
new file mode 100644
index 0000000..ae34083
--- /dev/null
+++ b/test/types/render_mode_one_of3_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render_mode_one_of3 import RenderModeOneOf3
+
+ RenderModeOneOf3Adapter = TypeAdapter(RenderModeOneOf3)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_mode_one_of_3_model_schema = json.loads(
+ r"""{
+ "title" : "_RenderMode_oneOf_3",
+ "type" : "string",
+ "description" : "Render timestamps and each series (column) as a values array. Show column headers.\n\n###### options\n- `iso_timestamp`: `False`\n- `header_array`: `row`\n- `data_axis`: `row`\n- `roll_up`: `True`\n- `include_window_spec`: `True`",
+ "enum" : [ "SERIES" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_mode_one_of_3_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_mode_one_of_3_faker = JSF(
+ render_mode_one_of_3_model_schema, allow_none_optionals=1
+)
+
+
+class RenderModeOneOf3Stub:
+ """RenderModeOneOf3 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_mode_one_of_3_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RenderModeOneOf3":
+ """Create RenderModeOneOf3 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RenderModeOneOf3Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderModeOneOf3Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render_mode_one_of4_stub.py b/test/types/render_mode_one_of4_stub.py
new file mode 100644
index 0000000..23b906f
--- /dev/null
+++ b/test/types/render_mode_one_of4_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render_mode_one_of4 import RenderModeOneOf4
+
+ RenderModeOneOf4Adapter = TypeAdapter(RenderModeOneOf4)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_mode_one_of_4_model_schema = json.loads(
+ r"""{
+ "title" : "_RenderMode_oneOf_4",
+ "type" : "string",
+ "description" : "Renders row index in `rows`, and each series as a values array.\n\nThe series are prefixed by their series attributes.The `rows` index is prefixed by the labels for these attributes.\n\n###### options\n- `iso_timestamp`: `True`\n- `header_array`: `column`\n- `roll_up`: `False`\n- `data_axis`: `row`",
+ "enum" : [ "HEADER_COLUMN" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_mode_one_of_4_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_mode_one_of_4_faker = JSF(
+ render_mode_one_of_4_model_schema, allow_none_optionals=1
+)
+
+
+class RenderModeOneOf4Stub:
+ """RenderModeOneOf4 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_mode_one_of_4_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RenderModeOneOf4":
+ """Create RenderModeOneOf4 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RenderModeOneOf4Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderModeOneOf4Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render_mode_one_of5_stub.py b/test/types/render_mode_one_of5_stub.py
new file mode 100644
index 0000000..b367e30
--- /dev/null
+++ b/test/types/render_mode_one_of5_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render_mode_one_of5 import RenderModeOneOf5
+
+ RenderModeOneOf5Adapter = TypeAdapter(RenderModeOneOf5)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_mode_one_of_5_model_schema = json.loads(
+ r"""{
+ "title" : "_RenderMode_oneOf_5",
+ "type" : "string",
+ "description" : "Render an object for each observation. Uses flattened keys.\n\n###### options\n- `iso_timestamp`: `True`\n- `hierarchical`: `False`\n- `show_levels`: `True`\n- `roll_up`: `False`",
+ "enum" : [ "FLAT_DICT" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_mode_one_of_5_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_mode_one_of_5_faker = JSF(
+ render_mode_one_of_5_model_schema, allow_none_optionals=1
+)
+
+
+class RenderModeOneOf5Stub:
+ """RenderModeOneOf5 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_mode_one_of_5_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RenderModeOneOf5":
+ """Create RenderModeOneOf5 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RenderModeOneOf5Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderModeOneOf5Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render_mode_one_of6_stub.py b/test/types/render_mode_one_of6_stub.py
new file mode 100644
index 0000000..f87f8ca
--- /dev/null
+++ b/test/types/render_mode_one_of6_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render_mode_one_of6 import RenderModeOneOf6
+
+ RenderModeOneOf6Adapter = TypeAdapter(RenderModeOneOf6)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_mode_one_of_6_model_schema = json.loads(
+ r"""{
+ "title" : "_RenderMode_oneOf_6",
+ "type" : "string",
+ "description" : "Render an hierarchical object for each observation. Shows an iso timestamp.\n\n###### options\n- `iso_timestamp`: `True`\n- `hierarchical`: `True`\n- `show_levels`: `True`\n- `roll_up`: `True`",
+ "enum" : [ "HIER_DICT" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_mode_one_of_6_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_mode_one_of_6_faker = JSF(
+ render_mode_one_of_6_model_schema, allow_none_optionals=1
+)
+
+
+class RenderModeOneOf6Stub:
+ """RenderModeOneOf6 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_mode_one_of_6_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RenderModeOneOf6":
+ """Create RenderModeOneOf6 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RenderModeOneOf6Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderModeOneOf6Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render_mode_one_of7_stub.py b/test/types/render_mode_one_of7_stub.py
new file mode 100644
index 0000000..225b042
--- /dev/null
+++ b/test/types/render_mode_one_of7_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render_mode_one_of7 import RenderModeOneOf7
+
+ RenderModeOneOf7Adapter = TypeAdapter(RenderModeOneOf7)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_mode_one_of_7_model_schema = json.loads(
+ r"""{
+ "title" : "_RenderMode_oneOf_7",
+ "type" : "string",
+ "description" : "Render an object with metric keys for each observation. Shows an iso timestamp.\n\n###### options\n- `iso_timestamp`: `True`\n- `hierarchical`: `['metric']`\n- `show_levels`: `False`\n- `roll_up`: `True`\n- `key_skip_empty`: `True`",
+ "enum" : [ "METRIC_FLAT_DICT" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_mode_one_of_7_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_mode_one_of_7_faker = JSF(
+ render_mode_one_of_7_model_schema, allow_none_optionals=1
+)
+
+
+class RenderModeOneOf7Stub:
+ """RenderModeOneOf7 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_mode_one_of_7_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RenderModeOneOf7":
+ """Create RenderModeOneOf7 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RenderModeOneOf7Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderModeOneOf7Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render_mode_one_of8_stub.py b/test/types/render_mode_one_of8_stub.py
new file mode 100644
index 0000000..92c2f2b
--- /dev/null
+++ b/test/types/render_mode_one_of8_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render_mode_one_of8 import RenderModeOneOf8
+
+ RenderModeOneOf8Adapter = TypeAdapter(RenderModeOneOf8)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_mode_one_of_8_model_schema = json.loads(
+ r"""{
+ "title" : "_RenderMode_oneOf_8",
+ "type" : "string",
+ "description" : "Render in an object format compatible with the `/data/v1/events` upload.\n\n###### options\n- `iso_timestamp`: `False`\n- `hierarchical`: `False`\n- `show_levels`: `False`\n- `roll_up`: `True`",
+ "enum" : [ "UPLOAD" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_mode_one_of_8_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_mode_one_of_8_faker = JSF(
+ render_mode_one_of_8_model_schema, allow_none_optionals=1
+)
+
+
+class RenderModeOneOf8Stub:
+ """RenderModeOneOf8 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_mode_one_of_8_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RenderModeOneOf8":
+ """Create RenderModeOneOf8 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RenderModeOneOf8Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderModeOneOf8Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render_mode_one_of9_stub.py b/test/types/render_mode_one_of9_stub.py
new file mode 100644
index 0000000..3c5d397
--- /dev/null
+++ b/test/types/render_mode_one_of9_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render_mode_one_of9 import RenderModeOneOf9
+
+ RenderModeOneOf9Adapter = TypeAdapter(RenderModeOneOf9)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_mode_one_of_9_model_schema = json.loads(
+ r"""{
+ "title" : "_RenderMode_oneOf_9",
+ "type" : "string",
+ "description" : "Render in csv format with row headers.\n\n###### options\n- `iso_timestamp`: `False`",
+ "enum" : [ "CSV" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_mode_one_of_9_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_mode_one_of_9_faker = JSF(
+ render_mode_one_of_9_model_schema, allow_none_optionals=1
+)
+
+
+class RenderModeOneOf9Stub:
+ """RenderModeOneOf9 unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_mode_one_of_9_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RenderModeOneOf9":
+ """Create RenderModeOneOf9 stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RenderModeOneOf9Adapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderModeOneOf9Adapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render_mode_one_of_stub.py b/test/types/render_mode_one_of_stub.py
new file mode 100644
index 0000000..77040d4
--- /dev/null
+++ b/test/types/render_mode_one_of_stub.py
@@ -0,0 +1,63 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render_mode_one_of import RenderModeOneOf
+
+ RenderModeOneOfAdapter = TypeAdapter(RenderModeOneOf)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_mode_one_of_model_schema = json.loads(
+ r"""{
+ "title" : "_RenderMode_oneOf",
+ "type" : "string",
+ "description" : "Render rows of timestamp and values. Show column headers. Includes an iso timestamp.\n\n###### options\n- `iso_timestamp`: `True`\n- `header_array`: `row`\n- `roll_up`: `False`\n- `data_axis`: `column`",
+ "enum" : [ "HEADER_ROW" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_mode_one_of_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_mode_one_of_faker = JSF(render_mode_one_of_model_schema, allow_none_optionals=1)
+
+
+class RenderModeOneOfStub:
+ """RenderModeOneOf unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_mode_one_of_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RenderModeOneOf":
+ """Create RenderModeOneOf stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RenderModeOneOfAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderModeOneOfAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render_mode_stub.py b/test/types/render_mode_stub.py
new file mode 100644
index 0000000..4cb8c9e
--- /dev/null
+++ b/test/types/render_mode_stub.py
@@ -0,0 +1,81 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render_mode import RenderMode
+
+ RenderModeAdapter = TypeAdapter(RenderMode)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_mode_model_schema = json.loads(
+ r"""{
+ "title" : "_RenderMode",
+ "type" : "string",
+ "description" : "Render mode configuration keys.",
+ "oneOf" : [ {
+ "$ref" : "#/components/schemas/_RenderMode_oneOf"
+ }, {
+ "$ref" : "#/components/schemas/_RenderMode_oneOf_1"
+ }, {
+ "$ref" : "#/components/schemas/_RenderMode_oneOf_2"
+ }, {
+ "$ref" : "#/components/schemas/_RenderMode_oneOf_3"
+ }, {
+ "$ref" : "#/components/schemas/_RenderMode_oneOf_4"
+ }, {
+ "$ref" : "#/components/schemas/_RenderMode_oneOf_5"
+ }, {
+ "$ref" : "#/components/schemas/_RenderMode_oneOf_6"
+ }, {
+ "$ref" : "#/components/schemas/_RenderMode_oneOf_7"
+ }, {
+ "$ref" : "#/components/schemas/_RenderMode_oneOf_8"
+ }, {
+ "$ref" : "#/components/schemas/_RenderMode_oneOf_9"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+render_mode_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_mode_faker = JSF(render_mode_model_schema, allow_none_optionals=1)
+
+
+class RenderModeStub:
+ """RenderMode unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_mode_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RenderMode":
+ """Create RenderMode stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(RenderModeAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderModeAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/render_stub.py b/test/types/render_stub.py
new file mode 100644
index 0000000..dc62937
--- /dev/null
+++ b/test/types/render_stub.py
@@ -0,0 +1,118 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.render import Render
+
+ RenderAdapter = TypeAdapter(Render)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+render_model_schema = json.loads(
+ r"""{
+ "title" : "Render",
+ "type" : "object",
+ "properties" : {
+ "mode" : {
+ "$ref" : "#/components/schemas/_RenderMode"
+ },
+ "roll_up" : {
+ "title" : "Roll Up",
+ "type" : "boolean",
+ "description" : "move up attributes on rows (or columns) that are the same for all rows (or columns) to a table attribute. Levels enumerated in 'hierarchical' are excluded."
+ },
+ "hierarchical" : {
+ "$ref" : "#/components/schemas/Hierarchical"
+ },
+ "value_key" : {
+ "title" : "Value Key",
+ "type" : "string",
+ "description" : "if set, use this key in the value object to report data values"
+ },
+ "show_levels" : {
+ "title" : "Show Levels",
+ "type" : "boolean",
+ "description" : "if set, report the levels used in the data values (either hierarchical or flat)"
+ },
+ "iso_timestamp" : {
+ "title" : "Iso Timestamp",
+ "type" : "boolean",
+ "description" : "if set, render timestamps in a row or column index with both epoch and iso representations"
+ },
+ "row_key" : {
+ "title" : "Row Key",
+ "type" : "string",
+ "description" : "if set, use this key as name of the row-dimension for single-dimensional rows"
+ },
+ "column_key" : {
+ "title" : "Column Key",
+ "type" : "string",
+ "description" : "if set, use this key as name of the column-dimension for single-dimensional columns"
+ },
+ "header_array" : {
+ "$ref" : "#/components/schemas/HeaderArrayOption"
+ },
+ "data_axis" : {
+ "$ref" : "#/components/schemas/DataAxisOption"
+ },
+ "key_seperator" : {
+ "title" : "Key Seperator",
+ "type" : "string",
+ "description" : "character used to concatenate multi-key columns or rows when required"
+ },
+ "key_skip_empty" : {
+ "title" : "Key Skip Empty",
+ "type" : "boolean",
+ "description" : "skip empty values in concatenating multi-key column or row headers"
+ },
+ "include_window_spec" : {
+ "title" : "Include Window Spec",
+ "type" : "boolean",
+ "description" : "if set, include window specification in render modes that support it"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Configures the representation of data sets returned by the query API."
+}
+""",
+ object_hook=with_example_provider,
+)
+render_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+render_faker = JSF(render_model_schema, allow_none_optionals=1)
+
+
+class RenderStub:
+ """Render unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return render_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "Render":
+ """Create Render stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(RenderAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RenderAdapter.validate_python(json, context={"skip_validation": True})
diff --git a/test/types/response_data_set_stub.py b/test/types/response_data_set_stub.py
new file mode 100644
index 0000000..dc370f5
--- /dev/null
+++ b/test/types/response_data_set_stub.py
@@ -0,0 +1,70 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.response_data_set import ResponseDataSet
+
+ ResponseDataSetAdapter = TypeAdapter(ResponseDataSet)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+response_data_set_model_schema = json.loads(
+ r"""{
+ "title" : "Response Data Set",
+ "description" : "Result timeseries data set, with one time dimension.",
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/RowDataSet"
+ }, {
+ "$ref" : "#/components/schemas/SeriesDataSet"
+ }, {
+ "$ref" : "#/components/schemas/ColumnDataSet"
+ }, {
+ "$ref" : "#/components/schemas/ObjectDataSet"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+response_data_set_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+response_data_set_faker = JSF(response_data_set_model_schema, allow_none_optionals=1)
+
+
+class ResponseDataSetStub:
+ """ResponseDataSet unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return response_data_set_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "ResponseDataSet":
+ """Create ResponseDataSet stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ ResponseDataSetAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return ResponseDataSetAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/row_data_set_data_axis_stub.py b/test/types/row_data_set_data_axis_stub.py
new file mode 100644
index 0000000..6c650be
--- /dev/null
+++ b/test/types/row_data_set_data_axis_stub.py
@@ -0,0 +1,67 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.row_data_set_data_axis import RowDataSetDataAxis
+
+ RowDataSetDataAxisAdapter = TypeAdapter(RowDataSetDataAxis)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+row_data_set_data_axis_model_schema = json.loads(
+ r"""{
+ "title" : "RowDataSet_data_axis",
+ "type" : "string",
+ "default" : "column",
+ "enum" : [ "column" ]
+}
+""",
+ object_hook=with_example_provider,
+)
+row_data_set_data_axis_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+row_data_set_data_axis_faker = JSF(
+ row_data_set_data_axis_model_schema, allow_none_optionals=1
+)
+
+
+class RowDataSetDataAxisStub:
+ """RowDataSetDataAxis unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return row_data_set_data_axis_faker.generate(
+ use_defaults=True, use_examples=True
+ )
+
+ @classmethod
+ def create_instance(cls) -> "RowDataSetDataAxis":
+ """Create RowDataSetDataAxis stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RowDataSetDataAxisAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RowDataSetDataAxisAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/row_data_set_stub.py b/test/types/row_data_set_stub.py
new file mode 100644
index 0000000..0705e38
--- /dev/null
+++ b/test/types/row_data_set_stub.py
@@ -0,0 +1,99 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.row_data_set import RowDataSet
+
+ RowDataSetAdapter = TypeAdapter(RowDataSet)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+row_data_set_model_schema = json.loads(
+ r"""{
+ "required" : [ "columns", "data" ],
+ "type" : "object",
+ "properties" : {
+ "attributes" : {
+ "$ref" : "#/components/schemas/DataSetAttributes"
+ },
+ "window_spec" : {
+ "$ref" : "#/components/schemas/DataSetWindow"
+ },
+ "data_axis" : {
+ "$ref" : "#/components/schemas/RowDataSet_data_axis"
+ },
+ "columns" : {
+ "title" : "Column Headers",
+ "type" : "array",
+ "description" : "Header Attributes for the column data.\n\nThe initial string-valued headers (normally a single `timestamp`) indicate that column to contain row index data (i.e. timestamps).\n\nThe remaining object-valued column headers identify and describe the actual series data.",
+ "items" : {
+ "$ref" : "#/components/schemas/Column_Headers_inner"
+ },
+ "x-prefixItems" : [ {
+ "const" : "timestamp",
+ "title" : "Unix epoch milliseconds timestamp."
+ } ]
+ },
+ "data" : {
+ "title" : "Data",
+ "type" : "array",
+ "items" : {
+ "title" : "Observation",
+ "type" : "array",
+ "description" : "Row index data (timestamp), and a value for each of the series.",
+ "items" : {
+ "$ref" : "#/components/schemas/Datum"
+ },
+ "x-prefixItems" : [ {
+ "$ref" : "#/components/schemas/Timestamp"
+ } ]
+ }
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Row-oriented dataset.\n\nTimeseries data layout with a column header and a data row per timestamp.\nResult for render options `data_axis=column` and `header_array=row`.\","
+}
+""",
+ object_hook=with_example_provider,
+)
+row_data_set_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+row_data_set_faker = JSF(row_data_set_model_schema, allow_none_optionals=1)
+
+
+class RowDataSetStub:
+ """RowDataSet unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return row_data_set_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RowDataSet":
+ """Create RowDataSet stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(RowDataSetAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RowDataSetAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/row_header_stub.py b/test/types/row_header_stub.py
new file mode 100644
index 0000000..09f414b
--- /dev/null
+++ b/test/types/row_header_stub.py
@@ -0,0 +1,67 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.row_header import RowHeader
+
+ RowHeaderAdapter = TypeAdapter(RowHeader)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+row_header_model_schema = json.loads(
+ r"""{
+ "required" : [ "timestamp" ],
+ "type" : "object",
+ "properties" : {
+ "timestamp" : {
+ "$ref" : "#/components/schemas/Timestamp"
+ },
+ "timestamp_iso" : {
+ "$ref" : "#/components/schemas/TimestampIso"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Index entry attributes.\n\nAttributes for a timestamp index entry."
+}
+""",
+ object_hook=with_example_provider,
+)
+row_header_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+row_header_faker = JSF(row_header_model_schema, allow_none_optionals=1)
+
+
+class RowHeaderStub:
+ """RowHeader unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return row_header_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RowHeader":
+ """Create RowHeader stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(RowHeaderAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RowHeaderAdapter.validate_python(json, context={"skip_validation": True})
diff --git a/test/types/row_headers_inner_stub.py b/test/types/row_headers_inner_stub.py
new file mode 100644
index 0000000..112cf5e
--- /dev/null
+++ b/test/types/row_headers_inner_stub.py
@@ -0,0 +1,65 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.row_headers_inner import RowHeadersInner
+
+ RowHeadersInnerAdapter = TypeAdapter(RowHeadersInner)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+row_headers_inner_model_schema = json.loads(
+ r"""{
+ "title" : "Row_Headers_inner",
+ "anyOf" : [ {
+ "$ref" : "#/components/schemas/ColumnIndexRowHeader"
+ }, {
+ "$ref" : "#/components/schemas/RowHeader"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+row_headers_inner_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+row_headers_inner_faker = JSF(row_headers_inner_model_schema, allow_none_optionals=1)
+
+
+class RowHeadersInnerStub:
+ """RowHeadersInner unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return row_headers_inner_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "RowHeadersInner":
+ """Create RowHeadersInner stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ RowHeadersInnerAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return RowHeadersInnerAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/series_data_set_stub.py b/test/types/series_data_set_stub.py
new file mode 100644
index 0000000..167fd5e
--- /dev/null
+++ b/test/types/series_data_set_stub.py
@@ -0,0 +1,106 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.series_data_set import SeriesDataSet
+
+ SeriesDataSetAdapter = TypeAdapter(SeriesDataSet)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+series_data_set_model_schema = json.loads(
+ r"""{
+ "required" : [ "columns", "data" ],
+ "type" : "object",
+ "properties" : {
+ "attributes" : {
+ "$ref" : "#/components/schemas/DataSetAttributes"
+ },
+ "window_spec" : {
+ "$ref" : "#/components/schemas/DataSetWindow"
+ },
+ "data_axis" : {
+ "$ref" : "#/components/schemas/ColumnDataSet_data_axis"
+ },
+ "columns" : {
+ "title" : "Column Headers",
+ "type" : "array",
+ "description" : "Header Attributes for the column data.\n\nThe initial string-valued headers (normally a single `timestamp`) indicate that column to contain row index data (i.e. timestamps).\n\nThe remaining object-valued column headers identify and describe the actual series data.",
+ "items" : {
+ "$ref" : "#/components/schemas/Column_Headers_inner"
+ },
+ "x-prefixItems" : [ {
+ "const" : "timestamp",
+ "title" : "Unix epoch milliseconds timestamp."
+ } ]
+ },
+ "data" : {
+ "title" : "Data",
+ "type" : "array",
+ "items" : {
+ "title" : "Series",
+ "type" : "array",
+ "description" : "All metric observation values for a single series.",
+ "items" : {
+ "$ref" : "#/components/schemas/Datum"
+ }
+ },
+ "x-prefixItems" : [ {
+ "items" : {
+ "$ref" : "#/components/schemas/Timestamp"
+ },
+ "type" : "array",
+ "title" : "Timestamp Index",
+ "description" : "The timestamp index for this result data."
+ } ]
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Column-oriented dataset.\n\nTimeseries data layout with a column header\nand a seperate data array for the time index and each series.\nResult for render options `data_axis=row` and `header_array=row`."
+}
+""",
+ object_hook=with_example_provider,
+)
+series_data_set_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+series_data_set_faker = JSF(series_data_set_model_schema, allow_none_optionals=1)
+
+
+class SeriesDataSetStub:
+ """SeriesDataSet unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return series_data_set_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "SeriesDataSet":
+ """Create SeriesDataSet stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ SeriesDataSetAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return SeriesDataSetAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/series_spec_stub.py b/test/types/series_spec_stub.py
new file mode 100644
index 0000000..b199e50
--- /dev/null
+++ b/test/types/series_spec_stub.py
@@ -0,0 +1,87 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.series_spec import SeriesSpec
+
+ SeriesSpecAdapter = TypeAdapter(SeriesSpec)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+series_spec_model_schema = json.loads(
+ r"""{
+ "title" : "SeriesSpec",
+ "type" : "object",
+ "properties" : {
+ "name" : {
+ "title" : "Name",
+ "type" : "string",
+ "description" : "Optional alias name for the series. This name is used when exporting the dataset to CSV format.",
+ "example" : "demoQuery"
+ },
+ "resource" : {
+ "title" : "Resource",
+ "type" : "string",
+ "description" : "Resource id for the series, required unless it is specified as a query default.",
+ "example" : "13efb488-75ac-4dac-828a-d49c5c2ebbfc"
+ },
+ "metric" : {
+ "title" : "Metric",
+ "type" : "string",
+ "description" : "Metric name for the series, required unless it is specified as a query default.",
+ "example" : "temperature"
+ },
+ "aggregration" : {
+ "$ref" : "#/components/schemas/AggregationMethod"
+ },
+ "interpolation" : {
+ "$ref" : "#/components/schemas/Interpolation"
+ }
+ },
+ "additionalProperties" : true,
+ "description" : "Query specification for a single series."
+}
+""",
+ object_hook=with_example_provider,
+)
+series_spec_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+series_spec_faker = JSF(series_spec_model_schema, allow_none_optionals=1)
+
+
+class SeriesSpecStub:
+ """SeriesSpec unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return series_spec_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "SeriesSpec":
+ """Create SeriesSpec stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(SeriesSpecAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return SeriesSpecAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/time_window_from_stub.py b/test/types/time_window_from_stub.py
new file mode 100644
index 0000000..8a1098e
--- /dev/null
+++ b/test/types/time_window_from_stub.py
@@ -0,0 +1,82 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.time_window_from import TimeWindowFrom
+
+ TimeWindowFromAdapter = TypeAdapter(TimeWindowFrom)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+time_window_from_model_schema = json.loads(
+ r"""{
+ "title" : "Time Window From",
+ "description" : "The start of the time window for which results will be returned. One of the [time line](https://docs.waylay.io/#/api/query/?id=time-line-properties) specifiers.",
+ "oneOf" : [ {
+ "title" : "ISO8601 absolute timestamp",
+ "pattern" : "[0-9]{4}-[0-9]{2}-[0-9]{2}(T.*)?",
+ "type" : "string",
+ "description" : "A date or date-time in [ISO8601](https://en.wikipedia.org/wiki/ISO_8601#Combined_date_and_time_representations) format. When no timezone is specified, the UTC timezone is assumed (`+00:00`)",
+ "format" : "date-time",
+ "example" : "2018-03-21T12:23:00+01:00"
+ }, {
+ "title" : "UNIX epoch milliseconds",
+ "minimum" : 0,
+ "type" : "integer",
+ "description" : "Absolute timestamp milliseconds in unix epoch since 1970-01-01.",
+ "example" : 1534836422284
+ }, {
+ "title" : "ISO8601 Period Before Now",
+ "pattern" : "^P([0-9]+Y)?([0-9]+M)?([0-9]+W)?([0-9]+D)?(T([0-9]+H)?([0-9]+M)?([0-9]+(\\.[0-9]*)?S)?)?$",
+ "type" : "string",
+ "description" : "Specifies a timestamp before _now_ as a period in [ISO8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations) format.",
+ "format" : "period",
+ "example" : "PT3H15M"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+time_window_from_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+time_window_from_faker = JSF(time_window_from_model_schema, allow_none_optionals=1)
+
+
+class TimeWindowFromStub:
+ """TimeWindowFrom unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return time_window_from_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "TimeWindowFrom":
+ """Create TimeWindowFrom stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ TimeWindowFromAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return TimeWindowFromAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/time_window_until_stub.py b/test/types/time_window_until_stub.py
new file mode 100644
index 0000000..7248de1
--- /dev/null
+++ b/test/types/time_window_until_stub.py
@@ -0,0 +1,82 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.time_window_until import TimeWindowUntil
+
+ TimeWindowUntilAdapter = TypeAdapter(TimeWindowUntil)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+time_window_until_model_schema = json.loads(
+ r"""{
+ "title" : "Time Window Until",
+ "description" : "The end (not-inclusive) of the time window for which results will be returned. One of the [time line](https://docs.waylay.io/#/api/query/?id=time-line-properties)specifiers.",
+ "oneOf" : [ {
+ "title" : "ISO8601 absolute timestamp",
+ "pattern" : "[0-9]{4}-[0-9]{2}-[0-9]{2}(T.*)?",
+ "type" : "string",
+ "description" : "A date or date-time in [ISO8601](https://en.wikipedia.org/wiki/ISO_8601#Combined_date_and_time_representations) format. When no timezone is specified, the UTC timezone is assumed (`+00:00`)",
+ "format" : "date-time",
+ "example" : "2018-03-21T12:23:00+01:00"
+ }, {
+ "title" : "UNIX epoch milliseconds",
+ "minimum" : 0,
+ "type" : "integer",
+ "description" : "Absolute timestamp milliseconds in unix epoch since 1970-01-01.",
+ "example" : 1534836422284
+ }, {
+ "title" : "ISO8601 Period Before Now",
+ "pattern" : "^P([0-9]+Y)?([0-9]+M)?([0-9]+W)?([0-9]+D)?(T([0-9]+H)?([0-9]+M)?([0-9]+(\\.[0-9]*)?S)?)?$",
+ "type" : "string",
+ "description" : "Specifies a timestamp before _now_ as a period in [ISO8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations) format.",
+ "format" : "period",
+ "example" : "PT3H15M"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+time_window_until_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+time_window_until_faker = JSF(time_window_until_model_schema, allow_none_optionals=1)
+
+
+class TimeWindowUntilStub:
+ """TimeWindowUntil unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return time_window_until_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "TimeWindowUntil":
+ """Create TimeWindowUntil stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ TimeWindowUntilAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return TimeWindowUntilAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/validation_error_stub.py b/test/types/validation_error_stub.py
new file mode 100644
index 0000000..dea8956
--- /dev/null
+++ b/test/types/validation_error_stub.py
@@ -0,0 +1,79 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.validation_error import ValidationError
+
+ ValidationErrorAdapter = TypeAdapter(ValidationError)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+validation_error_model_schema = json.loads(
+ r"""{
+ "title" : "ValidationError",
+ "required" : [ "loc", "msg", "type" ],
+ "type" : "object",
+ "properties" : {
+ "loc" : {
+ "title" : "Location",
+ "type" : "array",
+ "items" : {
+ "$ref" : "#/components/schemas/Location_inner"
+ }
+ },
+ "msg" : {
+ "title" : "Message",
+ "type" : "string"
+ },
+ "type" : {
+ "title" : "Error Type",
+ "type" : "string"
+ }
+ }
+}
+""",
+ object_hook=with_example_provider,
+)
+validation_error_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+validation_error_faker = JSF(validation_error_model_schema, allow_none_optionals=1)
+
+
+class ValidationErrorStub:
+ """ValidationError unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return validation_error_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "ValidationError":
+ """Create ValidationError stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ ValidationErrorAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return ValidationErrorAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/window_override_stub.py b/test/types/window_override_stub.py
new file mode 100644
index 0000000..5877d21
--- /dev/null
+++ b/test/types/window_override_stub.py
@@ -0,0 +1,69 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.window_override import WindowOverride
+
+ WindowOverrideAdapter = TypeAdapter(WindowOverride)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+window_override__model_schema = json.loads(
+ r"""{
+ "title" : "Window Override.",
+ "type" : "string",
+ "oneOf" : [ {
+ "title" : "ISO8601 period ",
+ "pattern" : "^P([0-9]+Y)?([0-9]+M)?([0-9]+W)?([0-9]+D)?(T([0-9]+H)?([0-9]+M)?([0-9]+(\\.[0-9]*)?S)?)?$",
+ "type" : "string",
+ "description" : "A period in [ISO8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations) format.",
+ "format" : "period",
+ "example" : "PT3H15M"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+window_override__model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+window_override__faker = JSF(window_override__model_schema, allow_none_optionals=1)
+
+
+class WindowOverrideStub:
+ """WindowOverride unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return window_override__faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "WindowOverride":
+ """Create WindowOverride stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(
+ WindowOverrideAdapter.json_schema(), allow_none_optionals=1
+ )
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return WindowOverrideAdapter.validate_python(
+ json, context={"skip_validation": True}
+ )
diff --git a/test/types/window_stub.py b/test/types/window_stub.py
new file mode 100644
index 0000000..ba258f1
--- /dev/null
+++ b/test/types/window_stub.py
@@ -0,0 +1,66 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol) model tests.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+import json
+
+from jsf import JSF
+from pydantic import TypeAdapter
+
+from ..openapi import MODEL_DEFINITIONS, with_example_provider
+
+try:
+ from waylay.services.queries.models.window import Window
+
+ WindowAdapter = TypeAdapter(Window)
+ MODELS_AVAILABLE = True
+except ImportError as exc:
+ MODELS_AVAILABLE = False
+
+window_model_schema = json.loads(
+ r"""{
+ "title" : "Window",
+ "type" : "string",
+ "description" : "The absolute size of the time window for which results will be returned. One of the [time line](https://docs.waylay.io/#/api/query/?id=time-line-properties) specifiers.",
+ "oneOf" : [ {
+ "title" : "ISO8601 period ",
+ "pattern" : "^P([0-9]+Y)?([0-9]+M)?([0-9]+W)?([0-9]+D)?(T([0-9]+H)?([0-9]+M)?([0-9]+(\\.[0-9]*)?S)?)?$",
+ "type" : "string",
+ "description" : "A period in [ISO8601 duration](https://en.wikipedia.org/wiki/ISO_8601#Durations) format.",
+ "format" : "period",
+ "example" : "PT3H15M"
+ } ]
+}
+""",
+ object_hook=with_example_provider,
+)
+window_model_schema.update({"definitions": MODEL_DEFINITIONS})
+
+window_faker = JSF(window_model_schema, allow_none_optionals=1)
+
+
+class WindowStub:
+ """Window unit test stubs."""
+
+ @classmethod
+ def create_json(cls):
+ """Create a dict stub instance."""
+ return window_faker.generate(use_defaults=True, use_examples=True)
+
+ @classmethod
+ def create_instance(cls) -> "Window":
+ """Create Window stub instance."""
+ if not MODELS_AVAILABLE:
+ raise ImportError("Models must be installed to create class stubs")
+ json = cls.create_json()
+ if not json:
+ # use backup example based on the pydantic model schema
+ backup_faker = JSF(WindowAdapter.json_schema(), allow_none_optionals=1)
+ json = backup_faker.generate(use_defaults=True, use_examples=True)
+ return WindowAdapter.validate_python(json, context={"skip_validation": True})
diff --git a/waylay-sdk-queries-types/.openapi-generator/FILES b/waylay-sdk-queries-types/.openapi-generator/FILES
new file mode 100644
index 0000000..4ec7e1a
--- /dev/null
+++ b/waylay-sdk-queries-types/.openapi-generator/FILES
@@ -0,0 +1,115 @@
+LICENSE.txt
+pyproject.toml
+src/waylay/services/queries/models/__init__.py
+src/waylay/services/queries/models/aggregation_by_resource_and_metric.py
+src/waylay/services/queries/models/aggregation_by_resource_or_metric.py
+src/waylay/services/queries/models/aggregation_method.py
+src/waylay/services/queries/models/aggregation_method_one_of.py
+src/waylay/services/queries/models/aggregation_method_one_of1.py
+src/waylay/services/queries/models/aggregation_method_one_of2.py
+src/waylay/services/queries/models/aggregation_method_one_of3.py
+src/waylay/services/queries/models/aggregation_method_one_of4.py
+src/waylay/services/queries/models/aggregation_method_one_of5.py
+src/waylay/services/queries/models/aggregation_method_one_of6.py
+src/waylay/services/queries/models/aggregation_method_one_of7.py
+src/waylay/services/queries/models/aggregation_method_one_of8.py
+src/waylay/services/queries/models/aggregations_inner.py
+src/waylay/services/queries/models/align_at.py
+src/waylay/services/queries/models/align_shift.py
+src/waylay/services/queries/models/alignment.py
+src/waylay/services/queries/models/alignment_grid_interval.py
+src/waylay/services/queries/models/alignment_timezone.py
+src/waylay/services/queries/models/cause_exception.py
+src/waylay/services/queries/models/column_data_set.py
+src/waylay/services/queries/models/column_data_set_data_axis.py
+src/waylay/services/queries/models/column_header.py
+src/waylay/services/queries/models/column_headers_inner.py
+src/waylay/services/queries/models/data_axis_option.py
+src/waylay/services/queries/models/data_set_attributes.py
+src/waylay/services/queries/models/data_set_window.py
+src/waylay/services/queries/models/datum.py
+src/waylay/services/queries/models/default_aggregation.py
+src/waylay/services/queries/models/default_interpolation.py
+src/waylay/services/queries/models/delete_response.py
+src/waylay/services/queries/models/embeddings.py
+src/waylay/services/queries/models/from_override.py
+src/waylay/services/queries/models/grouping_interval.py
+src/waylay/services/queries/models/grouping_interval_override.py
+src/waylay/services/queries/models/grouping_interval_override_one_of.py
+src/waylay/services/queries/models/hal_link.py
+src/waylay/services/queries/models/hal_link_method.py
+src/waylay/services/queries/models/hal_link_role.py
+src/waylay/services/queries/models/header_array_option.py
+src/waylay/services/queries/models/hierarchical.py
+src/waylay/services/queries/models/http_validation_error.py
+src/waylay/services/queries/models/interpolation.py
+src/waylay/services/queries/models/interpolation_method.py
+src/waylay/services/queries/models/interpolation_method_one_of.py
+src/waylay/services/queries/models/interpolation_method_one_of1.py
+src/waylay/services/queries/models/interpolation_method_one_of10.py
+src/waylay/services/queries/models/interpolation_method_one_of11.py
+src/waylay/services/queries/models/interpolation_method_one_of12.py
+src/waylay/services/queries/models/interpolation_method_one_of13.py
+src/waylay/services/queries/models/interpolation_method_one_of2.py
+src/waylay/services/queries/models/interpolation_method_one_of3.py
+src/waylay/services/queries/models/interpolation_method_one_of4.py
+src/waylay/services/queries/models/interpolation_method_one_of5.py
+src/waylay/services/queries/models/interpolation_method_one_of6.py
+src/waylay/services/queries/models/interpolation_method_one_of7.py
+src/waylay/services/queries/models/interpolation_method_one_of8.py
+src/waylay/services/queries/models/interpolation_method_one_of9.py
+src/waylay/services/queries/models/interpolation_spec.py
+src/waylay/services/queries/models/links.py
+src/waylay/services/queries/models/location_inner.py
+src/waylay/services/queries/models/message.py
+src/waylay/services/queries/models/message_arguments.py
+src/waylay/services/queries/models/message_level.py
+src/waylay/services/queries/models/message_properties.py
+src/waylay/services/queries/models/object.py
+src/waylay/services/queries/models/object_data.py
+src/waylay/services/queries/models/object_data_set.py
+src/waylay/services/queries/models/object_data_value.py
+src/waylay/services/queries/models/py.typed
+src/waylay/services/queries/models/queries_list_response.py
+src/waylay/services/queries/models/query_definition.py
+src/waylay/services/queries/models/query_entity_input.py
+src/waylay/services/queries/models/query_execution_message.py
+src/waylay/services/queries/models/query_execution_message_level.py
+src/waylay/services/queries/models/query_hal_links.py
+src/waylay/services/queries/models/query_input.py
+src/waylay/services/queries/models/query_list_hal_links.py
+src/waylay/services/queries/models/query_list_item.py
+src/waylay/services/queries/models/query_output.py
+src/waylay/services/queries/models/query_response.py
+src/waylay/services/queries/models/query_result.py
+src/waylay/services/queries/models/query_update_input.py
+src/waylay/services/queries/models/render.py
+src/waylay/services/queries/models/render1.py
+src/waylay/services/queries/models/render_mode.py
+src/waylay/services/queries/models/render_mode_one_of.py
+src/waylay/services/queries/models/render_mode_one_of1.py
+src/waylay/services/queries/models/render_mode_one_of2.py
+src/waylay/services/queries/models/render_mode_one_of3.py
+src/waylay/services/queries/models/render_mode_one_of4.py
+src/waylay/services/queries/models/render_mode_one_of5.py
+src/waylay/services/queries/models/render_mode_one_of6.py
+src/waylay/services/queries/models/render_mode_one_of7.py
+src/waylay/services/queries/models/render_mode_one_of8.py
+src/waylay/services/queries/models/render_mode_one_of9.py
+src/waylay/services/queries/models/response_data_set.py
+src/waylay/services/queries/models/row_data_set.py
+src/waylay/services/queries/models/row_data_set_data_axis.py
+src/waylay/services/queries/models/row_header.py
+src/waylay/services/queries/models/row_headers_inner.py
+src/waylay/services/queries/models/series_data_set.py
+src/waylay/services/queries/models/series_spec.py
+src/waylay/services/queries/models/time_window_from.py
+src/waylay/services/queries/models/time_window_until.py
+src/waylay/services/queries/models/validation_error.py
+src/waylay/services/queries/models/window.py
+src/waylay/services/queries/models/window_override.py
+src/waylay/services/queries/queries/__init__.py
+src/waylay/services/queries/queries/execute_api.py
+src/waylay/services/queries/queries/manage_api.py
+src/waylay/services/queries/queries/py.typed
+src/waylay/services/queries/queries/status_api.py
diff --git a/waylay-sdk-queries-types/.openapi-generator/VERSION b/waylay-sdk-queries-types/.openapi-generator/VERSION
new file mode 100644
index 0000000..1985849
--- /dev/null
+++ b/waylay-sdk-queries-types/.openapi-generator/VERSION
@@ -0,0 +1 @@
+7.7.0
diff --git a/waylay-sdk-queries-types/LICENSE.txt b/waylay-sdk-queries-types/LICENSE.txt
new file mode 100644
index 0000000..2796771
--- /dev/null
+++ b/waylay-sdk-queries-types/LICENSE.txt
@@ -0,0 +1,13 @@
+ISC License (ISC)
+Copyright 2024, Waylay
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,
+OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
\ No newline at end of file
diff --git a/waylay-sdk-queries-types/README.md b/waylay-sdk-queries-types/README.md
new file mode 100644
index 0000000..a7b6f6d
--- /dev/null
+++ b/waylay-sdk-queries-types/README.md
@@ -0,0 +1,65 @@
+# Waylay Queries Service
+
+Execute and store queries on the Waylay timeseries.
+
+Protocol version: v1.
+
+This Python package is automatically generated based on the
+Waylay Queries OpenAPI specification (API version: 0.5.0)
+For more information, please visit [the openapi specification](https://docs.waylay.io/openapi/public/redocly/queries.html).
+
+It is considered an extension of the waylay-sdk-queries package, and it consists of the typed model classes for all path params, query params, body params and responses for each of the api methods in `waylay-sdk-queries`.
+
+## Requirements.
+This package requires Python 3.9+.
+
+## Installation
+
+Normally this package is installed together with support for other services using the [waylay-sdk](https://pypi.org/project/waylay-sdk/) umbrella package:
+* `pip install waylay-sdk` will install `waylay-sdk-queries` together with the SDK api packages for other services.
+* `pip install waylay-sdk[types-queries]` will additionally install the types package `waylay-sdk-queries-types`.
+* `pip install waylay-sdk[types]` will install the types packages for this and all other services.
+
+Alternatively, you can install support for this _queries_ service only, installing or extending an existing [waylay-sdk-core](https://pypi.org/project/waylay-sdk-core/):
+
+- `pip install waylay-sdk-queries` to only install api support for _queries_.
+- `pip install waylay-sdk-queries[types]` to additionally install type support for _queries_.
+
+## Usage
+
+```python
+from pprint import pprint
+
+# Import the waylay-client from the waylay-sdk-core package
+from waylay.sdk.client import WaylayClient
+from waylay.sdk.api.api_exceptions import ApiError
+
+# Intialize a waylay client instance
+waylay_client = WaylayClient.from_profile()
+
+# Note that the typed model classes for responses/parameters/... are only available when `waylay-sdk-queries-types` is installed
+from waylay.services.queries.models.query_input import QueryInput
+from waylay.services.queries.models.query_result import QueryResult
+try:
+ # Execute Query
+ # calls `POST /queries/v1/queries/v1/data`
+ api_response = await waylay_client.queries.execute.execute(
+ # query parameters:
+ query = {
+ 'resource': '13efb488-75ac-4dac-828a-d49c5c2ebbfc'
+ 'metric': 'temperature'
+ },
+ # json data: use a generated model or a json-serializable python data structure (dict, list)
+ json = waylay.services.queries.QueryInput() # QueryInput |
+ headers = {
+ 'accept': 'accept_example',
+ },
+ )
+ print("The response of queries.execute.execute:\n")
+ pprint(api_response)
+except ApiError as e:
+ print("Exception when calling queries.execute.execute: %s\n" % e)
+```
+
+
+For more information, please visit the [Waylay API documentation](https://docs.waylay.io/#/api/?id=software-development-kits).
diff --git a/waylay-sdk-queries-types/pyproject.toml b/waylay-sdk-queries-types/pyproject.toml
new file mode 100644
index 0000000..9c18c9d
--- /dev/null
+++ b/waylay-sdk-queries-types/pyproject.toml
@@ -0,0 +1,73 @@
+[build-system]
+requires = ["setuptools >= 61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "waylay-sdk-queries-types"
+version = "0.5.0.20240802"
+description = "Waylay Query: timeseries queries (v1 protocol) Types "
+authors = [
+ { name = "Waylay", email = "info@waylay.io"}
+]
+keywords = ["Waylay Query: timeseries queries (v1 protocol)" , "Types"]
+requires-python = ">= 3.9"
+dependencies = [
+ "waylay-sdk-core ~= 0.2.3",
+ "waylay-sdk-queries == 0.5.0.20240802",
+ "pydantic ~= 2.6",
+ "typing-extensions ~= 4.10",
+ "eval-type-backport ~= 0.1.3; python_version < '3.10'",
+]
+readme = "README.md"
+license={file = "LICENSE.txt"}
+
+[project.urls]
+Homepage = "https://www.waylay.io/"
+Documentation = "https://docs.waylay.io/#/api/?id=software-development-kits"
+Repository = "https://github.com/waylayio/waylay-sdk-queries-py.git"
+"Openapi Specification" = "https://docs.waylay.io/openapi/public/redocly/queries.html"
+
+[project.optional-dependencies]
+dev = [
+ "mypy",
+ "ruff",
+ "types-python-jose",
+ "types-appdirs",
+ "types-python-dateutil",
+ "pytest",
+ "pytest-mock",
+ "pytest-httpx",
+ "pytest-asyncio",
+ "starlette",
+ "python-multipart",
+ "typeguard",
+ "pyyaml",
+ "jsf >= 0.11.1",
+]
+
+
+[tool.setuptools.packages.find]
+where = ["src/"]
+namespaces = true
+
+[tool.ruff]
+include = ["pyproject.toml", "src/**/*.py"]
+
+[tool.ruff.lint]
+# allow duplicate imports
+ignore=["F811"]
+# https://docs.astral.sh/ruff/rules
+select= [
+ "UP007", "FA102", # convert Union to | (pep-604)
+ "I001", "F401", # sort and remove unused imports
+ "PIE790", # remove unnecessary pass statements
+ "E303", # too many blank lines
+]
+
+[tool.ruff.lint.per-file-ignores]
+# do not touch imports here
+"__init__.py" = ["F401"]
+"conftest.py" = ["F401"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
\ No newline at end of file
diff --git a/waylay-sdk-queries-types/src/waylay/services/queries/models/__init__.py b/waylay-sdk-queries-types/src/waylay/services/queries/models/__init__.py
new file mode 100644
index 0000000..73e2608
--- /dev/null
+++ b/waylay-sdk-queries-types/src/waylay/services/queries/models/__init__.py
@@ -0,0 +1,231 @@
+# coding: utf-8
+"""Waylay Query: timeseries queries (v1 protocol): REST Models.
+
+This code was generated from the OpenAPI documentation of 'Waylay Query: timeseries queries (v1 protocol)'
+
+version: 0.5.0
+
+ Execute and store queries on the Waylay timeseries. Protocol version: v1.
+
+Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+Do not edit the class manually.
+"""
+
+__version__ = "0.5.0.20240802"
+
+# import models into model package
+from .aggregation_by_resource_and_metric import AggregationByResourceAndMetric
+from .aggregation_by_resource_or_metric import AggregationByResourceOrMetric
+from .aggregation_method import AggregationMethod
+from .aggregation_method_one_of import AggregationMethodOneOf
+from .aggregation_method_one_of1 import AggregationMethodOneOf1
+from .aggregation_method_one_of2 import AggregationMethodOneOf2
+from .aggregation_method_one_of3 import AggregationMethodOneOf3
+from .aggregation_method_one_of4 import AggregationMethodOneOf4
+from .aggregation_method_one_of5 import AggregationMethodOneOf5
+from .aggregation_method_one_of6 import AggregationMethodOneOf6
+from .aggregation_method_one_of7 import AggregationMethodOneOf7
+from .aggregation_method_one_of8 import AggregationMethodOneOf8
+from .aggregations_inner import AggregationsInner
+from .align_at import AlignAt
+from .align_shift import AlignShift
+from .alignment import Alignment
+from .alignment_grid_interval import AlignmentGridInterval
+from .alignment_timezone import AlignmentTimezone
+from .cause_exception import CauseException
+from .column_data_set import ColumnDataSet
+from .column_data_set_data_axis import ColumnDataSetDataAxis
+from .column_header import ColumnHeader
+from .column_headers_inner import ColumnHeadersInner
+from .data_axis_option import DataAxisOption
+from .data_set_attributes import DataSetAttributes
+from .data_set_window import DataSetWindow
+from .datum import Datum
+from .default_aggregation import DefaultAggregation
+from .default_interpolation import DefaultInterpolation
+from .delete_response import DeleteResponse
+from .embeddings import Embeddings
+from .from_override import FromOverride
+from .grouping_interval import GroupingInterval
+from .grouping_interval_override import GroupingIntervalOverride
+from .grouping_interval_override_one_of import GroupingIntervalOverrideOneOf
+from .hal_link import HALLink
+from .hal_link_method import HALLinkMethod
+from .hal_link_role import HALLinkRole
+from .header_array_option import HeaderArrayOption
+from .hierarchical import Hierarchical
+from .http_validation_error import HTTPValidationError
+from .interpolation import Interpolation
+from .interpolation_method import InterpolationMethod
+from .interpolation_method_one_of import InterpolationMethodOneOf
+from .interpolation_method_one_of1 import InterpolationMethodOneOf1
+from .interpolation_method_one_of2 import InterpolationMethodOneOf2
+from .interpolation_method_one_of3 import InterpolationMethodOneOf3
+from .interpolation_method_one_of4 import InterpolationMethodOneOf4
+from .interpolation_method_one_of5 import InterpolationMethodOneOf5
+from .interpolation_method_one_of6 import InterpolationMethodOneOf6
+from .interpolation_method_one_of7 import InterpolationMethodOneOf7
+from .interpolation_method_one_of8 import InterpolationMethodOneOf8
+from .interpolation_method_one_of9 import InterpolationMethodOneOf9
+from .interpolation_method_one_of10 import InterpolationMethodOneOf10
+from .interpolation_method_one_of11 import InterpolationMethodOneOf11
+from .interpolation_method_one_of12 import InterpolationMethodOneOf12
+from .interpolation_method_one_of13 import InterpolationMethodOneOf13
+from .interpolation_spec import InterpolationSpec
+from .links import Links
+from .location_inner import LocationInner
+from .message import Message
+from .message_arguments import MessageArguments
+from .message_level import MessageLevel
+from .message_properties import MessageProperties
+from .object_data import ObjectData
+from .object_data_set import ObjectDataSet
+from .object_data_value import ObjectDataValue
+from .queries_list_response import QueriesListResponse
+from .query_definition import QueryDefinition
+from .query_entity_input import QueryEntityInput
+from .query_execution_message import QueryExecutionMessage
+from .query_execution_message_level import QueryExecutionMessageLevel
+from .query_hal_links import QueryHALLinks
+from .query_input import QueryInput
+from .query_list_hal_links import QueryListHALLinks
+from .query_list_item import QueryListItem
+from .query_output import QueryOutput
+from .query_response import QueryResponse
+from .query_result import QueryResult
+from .query_update_input import QueryUpdateInput
+from .render import Render
+from .render1 import Render1
+from .render_mode import RenderMode
+from .render_mode_one_of import RenderModeOneOf
+from .render_mode_one_of1 import RenderModeOneOf1
+from .render_mode_one_of2 import RenderModeOneOf2
+from .render_mode_one_of3 import RenderModeOneOf3
+from .render_mode_one_of4 import RenderModeOneOf4
+from .render_mode_one_of5 import RenderModeOneOf5
+from .render_mode_one_of6 import RenderModeOneOf6
+from .render_mode_one_of7 import RenderModeOneOf7
+from .render_mode_one_of8 import RenderModeOneOf8
+from .render_mode_one_of9 import RenderModeOneOf9
+from .response_data_set import ResponseDataSet
+from .row_data_set import RowDataSet
+from .row_data_set_data_axis import RowDataSetDataAxis
+from .row_header import RowHeader
+from .row_headers_inner import RowHeadersInner
+from .series_data_set import SeriesDataSet
+from .series_spec import SeriesSpec
+from .time_window_from import TimeWindowFrom
+from .time_window_until import TimeWindowUntil
+from .validation_error import ValidationError
+from .window import Window
+from .window_override import WindowOverride
+
+__all__ = [
+ "__version__",
+ "AggregationByResourceAndMetric",
+ "AggregationByResourceOrMetric",
+ "AggregationMethod",
+ "AggregationMethodOneOf",
+ "AggregationMethodOneOf1",
+ "AggregationMethodOneOf2",
+ "AggregationMethodOneOf3",
+ "AggregationMethodOneOf4",
+ "AggregationMethodOneOf5",
+ "AggregationMethodOneOf6",
+ "AggregationMethodOneOf7",
+ "AggregationMethodOneOf8",
+ "AggregationsInner",
+ "AlignAt",
+ "AlignShift",
+ "Alignment",
+ "AlignmentGridInterval",
+ "AlignmentTimezone",
+ "CauseException",
+ "ColumnDataSet",
+ "ColumnDataSetDataAxis",
+ "ColumnHeader",
+ "ColumnHeadersInner",
+ "DataAxisOption",
+ "DataSetAttributes",
+ "DataSetWindow",
+ "Datum",
+ "DefaultAggregation",
+ "DefaultInterpolation",
+ "DeleteResponse",
+ "Embeddings",
+ "FromOverride",
+ "GroupingInterval",
+ "GroupingIntervalOverride",
+ "GroupingIntervalOverrideOneOf",
+ "HALLink",
+ "HALLinkMethod",
+ "HALLinkRole",
+ "HTTPValidationError",
+ "HeaderArrayOption",
+ "Hierarchical",
+ "Interpolation",
+ "InterpolationMethod",
+ "InterpolationMethodOneOf",
+ "InterpolationMethodOneOf1",
+ "InterpolationMethodOneOf10",
+ "InterpolationMethodOneOf11",
+ "InterpolationMethodOneOf12",
+ "InterpolationMethodOneOf13",
+ "InterpolationMethodOneOf2",
+ "InterpolationMethodOneOf3",
+ "InterpolationMethodOneOf4",
+ "InterpolationMethodOneOf5",
+ "InterpolationMethodOneOf6",
+ "InterpolationMethodOneOf7",
+ "InterpolationMethodOneOf8",
+ "InterpolationMethodOneOf9",
+ "InterpolationSpec",
+ "Links",
+ "LocationInner",
+ "Message",
+ "MessageArguments",
+ "MessageLevel",
+ "MessageProperties",
+ "ObjectData",
+ "ObjectDataSet",
+ "ObjectDataValue",
+ "QueriesListResponse",
+ "QueryDefinition",
+ "QueryEntityInput",
+ "QueryExecutionMessage",
+ "QueryExecutionMessageLevel",
+ "QueryHALLinks",
+ "QueryInput",
+ "QueryListHALLinks",
+ "QueryListItem",
+ "QueryOutput",
+ "QueryResponse",
+ "QueryResult",
+ "QueryUpdateInput",
+ "Render",
+ "Render1",
+ "RenderMode",
+ "RenderModeOneOf",
+ "RenderModeOneOf1",
+ "RenderModeOneOf2",
+ "RenderModeOneOf3",
+ "RenderModeOneOf4",
+ "RenderModeOneOf5",
+ "RenderModeOneOf6",
+ "RenderModeOneOf7",
+ "RenderModeOneOf8",
+ "RenderModeOneOf9",
+ "ResponseDataSet",
+ "RowDataSet",
+ "RowDataSetDataAxis",
+ "RowHeader",
+ "RowHeadersInner",
+ "SeriesDataSet",
+ "SeriesSpec",
+ "TimeWindowFrom",
+ "TimeWindowUntil",
+ "ValidationError",
+ "Window",
+ "WindowOverride",
+]
diff --git a/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/__init__.cpython-311.pyc b/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e0039c712eccb437c155fca1d1aca94be29a751
GIT binary patch
literal 9291
zcmd5=ZFn426`r(B(r&uhd^G(?n|Ax%w9WTt)6cX`+t9RWleDF`l<8)7vf1X`opg3K
zX+Q)-L_|bHL_|P9L3i3nB|)0bj@#
zmMD@hf4*zJx6yUJgE9!77L^hNaxk{KS_)B@eIwaUWFiYF16W
z0%~|It0le^mhn1PN8As~`3kmzcqOdltJo^y0jTGz*=pidu!c9V2IAGQmak*$h}S@n
zuV?Ft*TM$Ak!>Wt3^wu2Y%}pX*uuB6t;CnZHr~h@iLZd|dd?oDUO{|IdDrn{{
ztc7?zwDLCAMtn82^A6TQd<}H+F4jf70lIk)>mj}tdigH4i}*U|y0hFdtw8#5cncev}<0z6Fl)K{iNyD_qBqv*X0K
z!4N;eP7rT|lYE#B6WJz(-AOA_A;GkliK65j_``5c=g
zz8`MlH?y0GAAm3LTi7kc`{9fHR(31#gK!(ao!w6S5PXT>!R{b_7{1K!WOouDfUoeo
z*j>brz*qU*>~7*m;cNUJb`SAm@O6GKyO;PNe1qS|?jwF3e3ReL?k9d6zQrG44-g-M
zZ}SJ)gTzn3clbl>A>t?DyZmAHF!5pd9)E;ALi`kbpFheTC4L$n}BFNz%TeK>=oh{;g|eX_A2ok;aB`M_8M^&e$8KJuM@un
zzu|ANH;9MeP5u^pi}*PFmcPy3CLV_0@psre#3S%~{w{l$xCVdV@3HrYPrx7f`|N$<
zQTP-8fPFxG68_9TWFHcb!C&}C>?7ir!QvmYkBLvgU->8OlM*GWMBvF1_O}QhRT|@=
z$r4357n+06T<~;KGv@k&W{hhI&4_7<;1y}X|F_Mw1*Z+&)WbS7_60`Dl524@WXAM(P@f2H
z{ofwE)#sbhjD)L+-;3;P*
z!SwBB+T=oxrl&qWm!7m^)Q#Y_Nz=NHMA)0%fY!3Euklk
zu+|@soX|`o7M3F#@{Slb(gUiq21w(i9+6iq&oK_iwc!crS&`qWDZW@uES8+r_A@4p&L$dOBJ
z$1yDwq50Kh_tUekbgvk8pHS`GyWf;iF)pJXZ{~N5=VI}QJ}V8S(vakm)Ew3(LP;>Q
zUbVC?bF8$$X&or&q`mU62AZkK;G5Rt30$IYfRAgDNGu+uNgt8vJS-DNZVq~@jv9J$
zS~|0KYUO-e*7$}(J~t%GkM$1?#o|-)-hPLs1G&O6jOc*RuC}+X-!MXR>D^g+EG7$&
z5uS{N>9y4!8yh=yHUzNnO$D91q_e)@CbSmy;vN;g7B{J|7k8=J^W4#C4eMhmMh>OJ
zkRGP@olgD}S|SmOQph^A--yyVL}BgNhO`-tlHKXcBVt-JOnLapyZeU6FKb~FGfnpV
znVy~Kfs8@MTM{2ti)X34cqo=Ivr;NRN36`iSUl#GjVdw?#LbvFHyEEzQsuC1bhOFh
zl3780UWYq(KY5*0p?Q}$|CXlhtBDrnSj(zK^y`?Ho{`=vov7CGFW
z{+Vf+WSaY+vJowASGIDS;Vbvq6jg)l1u{K1sjB9g@S^!PjE?!XjyyI@nEB%{Pv+Y&
zJ?7gmE9ToU8RpwC2jnvBa*3f~2ZL`!pUw1YGCedp2fz|(O;`Uwx|1&b{!t2^%x!$O
z!3p+CJcsOhk3|{hk+GbSk%WO9$Sr+k=`*6zX6f>LSyZU1BZgGfSSV$Qu?RtaB`Zc5
zLOH@>ge3_0iEUIMEJg4mR3Zcrst~FXY7lA>mLb$3EJs*@uo7VvLOsH2gf$2a2x}46
zAp{ZDBWys}h_DG^Gr|^xtq9u?b|5q&Y)9CM(1g&8(1Os5unVCNVK+i6LK{LmLI*-8
zLKi|eLJz_oguMv+5cVS+KRD??iA%t;+FhT@DLzqB_B1|I05H2H3
zNjTZ~cTujYQoGB*0BH~#LK(HHj?bxvqgPd_!BtL*l_E&2FEmg$+;JFWq9%Ksynz(2
z6nJ7)u0xgbOVuYRCPjTge;dVXkpb-#%S8rsP@EST&`CK^WIz|?N09;DlsiQR^iW1i~FIROE%2Y~3t@}{9cvme`eG!4QXO<*06&z72tw~OGM_y|S
zXEiIls2GVl*F*c_s%NTE^1dXXF)jQ_&JWEiIy{fC)c-7OT1=q^X{X>ZqfoGy9Dt
zPSoevGZ$j{6YC2Pa1#Y9q*y!|0u`i0qFN~eZWq%Kvki-<@TaYYl-X2EMXmi7)DTK-
zcZ0FEilviTa+@lxsKXCrRem%%l3SHws2fy|h2OhlSd_&wkIkJ6mTIv&pUYhm)^V|>
z$cQ$o@OXSb-(N$XQpqJvxnvMf}_@MIU&*;X0z
zQt#toFY2z?%3r2i!psx{)BvIieRHZTB98tiRUm3?vn;Ff8$d2kDsNH>Vuj;yKLlio
z(6f$tJ=#%g&_j=7&o&MBsoNdZMC0-`a>+UEi~uMU{odUEyxv<-v}gA#8UeL
zoxT%Dw1`UEl&*g$V%%}kD8Cm-(zwe_(l>*%T$DMY%%JZEk~^Z@?zEBa5fye%{1^
zM3AV-vbco-g^{Sub+nOM%I9e(36;;&LAolRr<251K2H}Zuza3wl4bckJ*3t0d3s5}
z<@4+!RVS+5t&wuv9OlNXPWOzM5dZB
zoaHCHywtrS+iK2D%UdOku;Xk=-@>`B1!ENwEvgLhn5nAG({rCK-Xo1k(DoVsl+!Jd
z{}KyRpMkJT0Ycx4bQ-?6JHprEImlEv0l?
z-j-5!THcmY+AVL(_pFtc;%OA5q^&8FO|Hd~6P<=aEg069M2oa-&c)AH?n?hHLCN$(2&nuR1
zJf&>1ye;2*UvDX%mhy%Q-6!|$C%|O9rM$03zNy?QdTr5ENyUO|N(OH$
L$G^rub_L;kLi}?h6
z13m&mVqoNBWMGIqAu)A})J~mvPMkJEREX2*{Qke+@9z0?vuP7t$D^G#u=Yr+;ngT1Z@oP7a`rj{k#92<#vnn2AlW;#l;5r62P_p_ai2#m
z7V`ii*|F{YVJMl88aweM8$bfWQxLGe;4xD}V7nNS+BF
zcEt-&BJ@8zTyV1()Q|^~$rSvsAL3o5Aeg9f7!tt<%<8;sEf;my#fx*@!gk$$rZNGp
zD|BpH)Ks2^$v_yWh;n|4m6^qb_X-k;P^GAq_O0r%yeo|EVeZa5x?H%kj>0O#b*V(L
zwt)DGP&Wx?jJ}XF3?&!eogt6G5m|!o?woLOKDg4UmT$ZTvoEc5$I+|V*R6ILreqlYr@GOGI;sz4IAArbjcuaIk>BO+8
zF(Kt~lhC^(vc9+{hEBB!`S)RKW!!a#Md$$?k^RN}^UlWDXpXJrk9(t4XVi3lSog=)
e69m=h(sNxmYv;PTu8qjrWSP*75xFN;5cF??+*-r{
literal 0
HcmV?d00001
diff --git a/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_by_resource_or_metric.cpython-311.pyc b/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_by_resource_or_metric.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..66fcd1a8122941c1453f3becc23e31ccf1891b68
GIT binary patch
literal 1188
zcmb7D&1=*^6rX(UX0zQw{W$bcJGCu#!ENZ#B0@!wf?7W+LM|aq-tLAbnK(0Pjemmw
zfLCuKc=w<1kV6k;PlBi37TQw};>+%~jm07k!{oj9dmq2|X7ah!vIwrd;%oPpO32Sr
zIa|h9P>w&K@R0<>A%PO8krJzps+6)8X|e9;vEdjaU5{#U-KnE&1hvSF8%|>+*CQ)#
zI!%Ru0d;5uW>=j(t3uGCL-Rrp8dbC^J5z!6inN|9
zeT$azyRx@NQ_dvwS=6R63m_7!mbKjv1@%#*`<|dZNPv410@~#)rm_!oD}`j^`6dmR
zpT&?!Plha^tV{3wU&%X`_4qvdPJW(uVq~1I^rcM2x@|Ko>7`+3!iMox34XtAS&tY^
zn4}Pda>UJ#JRxZ8C7BmRId*eYjZI|j_{I8
z|CxK^Kvq7KQw4@)imt~yMjtQX{7
zbszqzBJ_hUAL^}Qdj8Y3VtVmFUqbEBoGMzk4$S#tVY@K5Pc+r24K>ZEpJ>K{T9CQn
O6j7E7vc#`rL%#ufvTT+B
literal 0
HcmV?d00001
diff --git a/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_method.cpython-311.pyc b/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_method.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6070321dadb71a3585946e4aa142aaca00c73793
GIT binary patch
literal 1994
zcmc&!O>fgM7v|R?6^4TMt=zs
zr`-UFACtolQ%^`-*sany?SzxI`yh)}4v5HdpZ9ql+i(5a{+!FnfPZ`5x5m!|06+X-
z^koM?IC&-j@DZ3m1Eyfcus~v3Oz?3W$BC$k0TywBB()^R2{VaPMAD=Hr*N9cnjByW
zXGm7d1~`p#MA4K0%Xot1wS0gxxIiYg$pB~Z4N}yK0nXtmQqoERR`4__Yh?i-5hami
zPBdbbQPzMna)`->7$wByL(F7|DTbI*h$&xY8tL=gw2GO34XOo$?-O`ubg|KeuR4fz
zH=t_~Z&A;@+O*P=G04LJLEOU}yj*4gYk-LrXzBxP`}<+^QWLscnX(r8
zVK$V_yQto(%JL%$ZR$c~T5gbA9UG1ViD7pPjJy2b9Q%c<3cZYBb7PRI!^6Z|n8(zyKT#EGSLqTgFr_gTx2_Z2OY+*HRz2_k8!?r
zItlhpr#8}QgQa}it>Gbyv@I}cEZ-takL6op{`+(Ny2~sxmT!gmuh#YRt+L!$zBQ(d
zg-2>(+)kE>#zmNI_DRKW-T%L+~pwKS?q2hrugS!~N-WVdV8dhjKA^FH$4{N}xvydN1UBcNvcqgTx#
z^wlWGRO|`3dmn^7#83?}%yIz^bF~~caz4n1R?WgFhvpHpb`dM^0=M=pgbv{8QLV^|
zE2uI=ix{Cb+6rikJWjZ5%@FN}Tyg1hMK-`<)~V(#5=)_lD}o9M1>=FLmdmRRUlA8H
zvPl)G^N35TIU}AFA<+#^mSY~xK3X75xJk$(O|>r~B0O^A|F*nQF3%6LKWh#0_KiZ4
zsfO0Enz3yGThiE{?xPX1s=3>!l*BT4D64;kXh9^8C3GUv1P~HNH6Q|2Xd^vQ0BklQkep!xQukn8qlHciuUYZ|7g>APH=X8O~o*!pyT+#vKg
z;-po#Vo0T=+jrW76#Y26H<&j4Rd6TFD(;AgJHo5Rt#rt7pfrxNHFM0y5*T^daW-JO`X1OB
zz5_599xgmtS(WD?{sWSuCe4Up=F`sD1rXG2U^|2Bv$fW?)((fqcIG-3E?nuLf3RLY
zlWM6lB*$Pikh}z@0w75<2C2niq^0>6WcYgr`j3AYgZqI4=Q}p8O?p)gRcfFk;Ex02>?uhDiIcg>YjsvxEoUQRQ`cm#~xC$3k
z7lG}dufvz#%)Fg_wf%a#RT%4l4VkhOU`=aN$|nWK32DF`Cn-7(0EvAgpLd)M7_XiO
zj)o5b%+})E%Bs8o;UAG4Hd%%YGoN1DKwgH`AgabN7Jx{aIY=xHBQ4E;K?=Wn@TgJyV2%oRySKO}uY<#MTdf0YXEDZY
qtAMRGGVBV%H(Th&$>$J_w*GwD`8)>1|FU=P`oX-uuPYSmLa=%J0!EY^Y$L@cxv4{a3-gxl^Rae6
zgV0xFoQ`~7!M#VI93Y0Oh+&rTageEIu+g)AHn6G|Mj5n(n6-~sj_0^_Xd!e2Z+}$t
zEdLCZhG-rmv`*VTZIh=Fm+cDCUceQX9#>=wJZ7G5-6c&av~Y!AB7tDsSLI@Ht>G!+
zfWa|HpoGKQV2H7{-gS@Fz
zNHX2fx~VF*E#OGn^kz~tLY6gm8>M1#L6A^r!kMQNY_3n0A^{B}>iccD%{RkL3CF`U
zgoO!I1*WwaMuD5smP}9*GjMML
zmbq>Swi@!)+U(ByX@C<(H6?H_!&$&-NLtj7c!jKit)jp%mUt9lUdv-ZF)RjH8(f;0
z*noPq`iRTr*fJ^NyyQBPVVqT3x=`f7$btqh?%e_90O>Qa7wGxGIt1-#U_r0ol~P7t
zfIV?80b{sP+^;FKh@5<~8zSJgj6!Gwdt1m&dpqf?nPz*&;PYIr&U5`4Q*3i4Z9Ld|
zy5p=@x0{ekNjDAJgB0mLyWgTV{YAYKB-}e9!h$Jv=Ytps%E*%Fo0
z1=rz%>N1Eu^kwwQ>$x|Tm%FcaJB5iJ_>iHc0CU1kDIXUcC!_&)oVe&X03`B_e$jEZ
zpwrR_91Y(DxUJ>I`4xEywtql!)MObk!hGe47z0J!1F<*weYR-FqQ}Eydkb9)=O(-8
zAEKYnq*^Hr$*V9MM70Ro0uV{l2eHMWjimWoNZ|Jm9yjIy%t_%v{}vDBO$eB3t4$Ey
uEXKHN6|mJsMqESqb_d-$`y8Y3&hJk*pT~gsZ}HZBH}~E6f1DFc!2ASmC~ral
literal 0
HcmV?d00001
diff --git a/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_method_one_of3.cpython-311.pyc b/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_method_one_of3.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c433ff2e811bbc040fd9ed6550c4199f35678440
GIT binary patch
literal 1362
zcmb7Ey>Ht_6u+Y=T2$`Ec7QIW&Wu
zLqPz0@Q?r*G8AyfPALj^=%3=5K!E_Ax+!p`Onpa6irY9tkL0`e!S`{$_sC!8=j#O5
z@c8#m;t}$f6Q(OD8G7<9GKWNvHW5^K2~EAWM;%{DDyiT0De=f%BK!j)s!#?0rBBEa
zKILi$BG@90IUZ0#9`I4ZN9>0T^k|jYehLP39}Ihh8n-VEm)Srot74TjSgHghrd6+R
z_xgs#D6w5`SQjK{Zb7h)Rw=VRV4DMwYv12vLd97M(sJ8ZlBo_`{C_DI>-D>{=s%8T
zaVJWp*;3Eifmsbhg(>-<-<(vVbjw2AYt-v^6qCv_5Pe(J7AM>omU5Z#BpKmp{&vVT
zX#O#m_+nA2LD65ASsG7ZD>iJ2TlC}#(nA8IO|cE0pzVtA+P;_*)dRm>EdZ|NpRaYh
z8oEWi`(S%YY)aVdtUP`?H2@Rba)#$}n59@Dmu$$B3|84TYGin`X?vxH?e+i>)B-e!
zuL=h~MA*CFV0HdWvbo$SJ-8Go-k6F-$TEOr*ttx?5M-;B2W8GY&|oty^NO)L#<`fS
z3Uc_+lk3PF5_`(_ggl%{FOfT%NjP3~qv7d~&?m1J$sL>ql8$jNvA2JOJ(WVJGl`QE
z?kc?#?iQoi9E_Scg2R3c<}B5JZAR=gC$oyKQ;*YHI~rgpqvMG&oQ0V9h2>O-{9U)A
zv}jkPBt)vS(i)8NxhO(xqUiC}Y4dQPPj|I7dEqlWp!pQZKKb+f#TU1JT79r{&!=aR9)N=}Wk~$~qa2
z2Ue!tJmfy$hoRjcr8q{Je!+>elHS&Cm#6tge}M+qb+dzHT%nYX{TlVh#F5K{UOOgV
gp1xm^h2wwU;~=0|@%!ZG_?KI+o&L=k#-f;i01AmS6t|Ph2M48m6_{EBLmQ;zgveAOL{(75&=%Apq%0?Mc9Nra=hXJ4N`=%8
zU62?UkjltZgv!95k`bMRREdc#C`_GrzJySq9dPcR--rGD^Y6XO`>`<_!Dx3s)~{s{
z`f7|{BR^1Z{~jp2h@l!{m}LSSW@;I1^lXp~t(t{V1}z|F?I4!pId1J)2<^i=7_~gh
zub@(a<}pG~X(yl^@;K(QGfT7|a>b?36Re^#kNWw;1QQpb4Kb?ghV$vS#I%Y?$JZSgcpZA(p38*BBD;F|L@3Y+g=!Df7Ti09Xf?1
zGfk~qYSwWC97$V#d5A{HisoLkWZU-ziG(Jc`8vhs1ym^#(kP}u(1F{0Gt885a+*f4
zFomkXv>rrp=nZL0Cn$*-xIYPU7jaa>P=*Y{wJgijELLE-9jlg02`(mA<{Ayj8)?2p
zuA71_M|`g9hZ`D0(XbV8;zycGSYD|l
zSy-OrCD*Zxz|hizdX7dGGXfO0z2>?uvS~(&{7y*9C4|cXR55YE*^`F2e=YIS||E%lL)Y
z)i<**w_a^^i<5ouAwx?M=9HUKJ}J6xL__YniS4=oBo2&z#&y@BsfH0a8rmP+*_9`Y
z@+|EBfaJJIGG>JNo>Ori6m=WK_UQN7TI^bj2ln{(e9ywUsUA8(4Dy*&OQnLm2(tlH
zkD)67kTh+OSRDFTnm>RP{ovpUV~)Ta7Viu$aaUf2fGM_G1JTQ3jC)oQTRmjNC4_Hu
g(e@6!Q6u#Yk^FC(Y`^|fAKMW5S5zt2WQ+?b(
z=$lrKDK`*se-4B_L{SY3B|uJPn!X%o5e|nPj5HBv}WGUZ*y0leXZByWA@gpHt?^O0l@yY)RsR
zMm8Nu8Z2PKQH+wh;671JMyhQV%s+WVD0f4j1tDKI&(AoSg&Z1Dmu(S-XG!1oYCH4JSqD6VCwQ8Q_tW_Qh6HZE`>x;Ecv2-b+>
zJ!Y!OX*FQg`pnkd70Cujco-;M6}}2}-xy>jtsr(v$8UQKG^Jf$r4nUby+6tcra}=!
z8L5N|O-v~R5`4IS3xqwSPWWD;7pb-n(m|@hEa0V*AC<}=~rtdD9SC@JdIr?lh
zxz8*S2GC|}lZ!QLGoG7ryHnPimG3yvP2IB8X#HiVMGO`KL5A~|Ob
zM$mG8m)7><+S)u|Hm}cA+MOtG+fW?Sg0k)GqU(C6#Id?cTy0g$TadxtY&R~OhI@D4rFGgY2km@1K1wayd
z5F(So_zL~s$M^?{$F!P)IV#*6T;skN2ZwIATm#n2V2pca0h>Lf*%gFubkX&b?;#rN
Z{`vNDISh#ZW$)bg(?7KR=PAw@%rBvmWJmx2
literal 0
HcmV?d00001
diff --git a/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_method_one_of6.cpython-311.pyc b/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_method_one_of6.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4736aaf4f0b49a77a4dd50393d22b3485fde367b
GIT binary patch
literal 1285
zcmb7E&1=*^6rb76ei*IwtLmv86lqu34Pxn`h*+!?54M(8guR3`GrJp`WYU?*mMubi
z=tc10L8wPh6{!dRls!s7D0uR=QcpekCcBMQ+kKernvx
zA@ofvM^x+!_}~EuJBXq>qL}7<9OUXbtmV9)4~)8jQ4Y-^YHTA~UY0LR#Q*a&4yB6s(!%
zd%{$U(}j>NG^RG@o=KJ>k;)0FBPgM)?PVnbRD`cUBiel^#0&eoognfVXiB^MS}n;-
zMU$dnDi)zugbO{*C=U|6_~14OJ4hY#y+kiEZ5O1yOoP$D^Oc-912IVfj)|Erg=Bt1
z>P_VEv(@4OvqT(1*R6FfR;~4PjH*$ms!@9`lP8(}_DQ;09n2Yo9z`6ts!jx{q;LmL
zD@!qmv-%ThIln7y2WhEo9x|IZrfN|qDcLsE#>>#AF0ifa_r+N38jJhp@YchgfeT|jbPDU|)2ZewC2<*64X6>r
zQ~)5M#~?8n%(Bpb0xA0b!6RDDz#NwE^)GQ>TnC44wp<0)%VUgtMj0DDq}dgOZ+6j*
eHhijibV{F|7Gvo_me-g{pShJ6wEI?iD_p5
literal 0
HcmV?d00001
diff --git a/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_method_one_of7.cpython-311.pyc b/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_method_one_of7.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..25586ae03acd85f62ed86f3139f2de708f013a42
GIT binary patch
literal 1268
zcmb7D&1=*^6rV}5*)>}0N2{LNK@aT;yFn}#ib#t}@z7RLQT7sIGP@g_WYU?*)-6JN
z=tc10L8wPh6{!dRls!s7D0uR=QcpekCc9m$wg+F5H}7NKo8P?m@?mJmLO`v~r}~J7
z&^M(Vkl7RP-Yf`P$VWBgV_yq#q}4R6WIfa)qh?^Fp?TyRo5(NF0yVY`gm&QTQO)$t
zhp1e1O^nbJw;j4|@*t(WJws#=Q9*e?1z7=$S|?lANWz(99t+DPVm=K;)v_Kn13^5{
z$f_$ygT|D*lKQ01Swv)$lBI;kbNBBNpLuCSW9iC(#e~(##Qz;RVOjHo?9bYRynQ3%
zWU?t`B4%ux!I5qfRQhNbuS)7Q%a(PAk(fzB{Xpi}ywDYbL~fkAVc3S-d{>nzw@>)XmHt>k=t0C`t86EbN^r05v+BnYI_%RKr_BULB3yL$qHqh7Mb8n{J&b(TG
zz1}H}?ST!cvXo%WYg0C}lH(uy90!1;p^{HI&I-&?-vdX(#DiI1n0v}kL-a?)
zhgFgx#ndmHv$G(G>%cY!&lh91W6bVa!yC7|1}=|Np(zXT4|Y_SZit7DA2MhP2Tq}T|;S32nO;dd8}
acK&?3rilUZzwDj&e(Hy^|2)E(gZTxiQDRpB
literal 0
HcmV?d00001
diff --git a/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_method_one_of8.cpython-311.pyc b/waylay-sdk-queries-types/src/waylay/services/queries/models/__pycache__/aggregation_method_one_of8.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b837462ba0bb5b5de0a699327a71441da40ad65a
GIT binary patch
literal 1268
zcmb7D&1=*^6rV}5A4Y5aXw_3Y=)tbA8^j`|h_tAb9@;7@LM|aDv%9fLW;-+4k|MN+
zUIY&wgnIN;k$Uh?*`ox6f+ue)>!~N-WVdV8_TWqM=6%e2^PBfxK8%c*2&mopR3Fn2
z`lggaD)t53n*(77`N&2-_O%d4nyq0a>!BVQwt#iUT8dL5{>XSNW5s^(wR$4Tkf4E3|<|Pr0r7Hs#6ILhJ|L@4_rnxZ8{yZJ#9T*uW
zQ%xybV%D-49O<@#>HrPnHA%f@#We3T5;IAtAIKb=7rH`_$c+;>3{$wxcU74R&Q7~A
zY|NnwP>lz15_yBN6*NZ@1#u81k*W(oA#FEIpyolGJB1syLJFFs96YsJro;ZM$f-urAala`4$|
zvWQwdiJ{5XI^(O>dOkJPR$7H=X$Kw^$C>{234gUZ7%K=pj5unQX$w*b?hTyQFvTFw
z>JOmh{w}N&<&||