=== Файл: AuthorizedApi.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface AuthorizedApi  {
    FastMetaApi<AuthorizedApi,AuthorizedApiRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_150, DataIn in_, AuthorizedApi localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_151 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_150,in_);
                        var futureRec_152 = serializeContextVar_150.getFuture(requestId_151);
                        if(futureRec_152 != null) futureRec_152.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_153 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_150,in_);
                        var futureRec_154 = serializeContextVar_150.getFuture(requestId_153);
                        if(futureRec_154 != null) futureRec_154.onError(in_);
                        break;
                        
                    }
                    case 3:  {
                        byte id_156;
                        id_156=in_.readByte();
                        String[] argsNames_157 = new String[] {
                            "id"
                        };
                        Object[] argsValues_158 = new Object[] {
                            id_156
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("backId", argsNames_157, argsValues_158);
                        localApi.backId(id_156);
                        serializeContextVar_150.invokeLocalMethodAfter("backId", null, argsNames_157, argsValues_158);
                        break;
                        
                    }
                    case 4:  {
                        int requestId_159 = in_.readInt();
                        long nextConnectMsDuration_160;
                        nextConnectMsDuration_160=in_.readLong();
                        String[] argsNames_161 = new String[] {
                            "nextConnectMsDuration"
                        };
                        Object[] argsValues_162 = new Object[] {
                            nextConnectMsDuration_160
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("ping", argsNames_161, argsValues_162);
                        serializeContextVar_150.regLocalFuture();
                        var result_163 = localApi.ping(nextConnectMsDuration_160);
                        serializeContextVar_150.invokeLocalMethodAfter("ping", result_163, argsNames_161, argsValues_162);
                        result_163.to(()-> {
                            var data_164 = new DataInOut();
                            serializeContextVar_150.sendResultToRemote(requestId_159);
                            
                        }
                        );
                        break;
                        
                    }
                    case 5:  {
                        UUID uid_166;
                        ClientApiStream stream_167;
                        uid_166=FastMeta.META_UUID.deserialize(serializeContextVar_150,in_);
                        stream_167=ClientApiStream.META.deserialize(serializeContextVar_150,in_);
                        String[] argsNames_168 = new String[] {
                            "uid", "stream"
                        };
                        Object[] argsValues_169 = new Object[] {
                            uid_166, stream_167
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("client", argsNames_168, argsValues_169);
                        localApi.client(uid_166,stream_167);
                        serializeContextVar_150.invokeLocalMethodAfter("client", null, argsNames_168, argsValues_169);
                        break;
                        
                    }
                    case 6:  {
                        Message msg_171;
                        msg_171=Message.META.deserialize(serializeContextVar_150,in_);
                        String[] argsNames_172 = new String[] {
                            "msg"
                        };
                        Object[] argsValues_173 = new Object[] {
                            msg_171
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("sendMessage", argsNames_172, argsValues_173);
                        localApi.sendMessage(msg_171);
                        serializeContextVar_150.invokeLocalMethodAfter("sendMessage", null, argsNames_172, argsValues_173);
                        break;
                        
                    }
                    case 7:  {
                        Message[] msg_175;
                        var arraySize_176 = DeserializerPackNumber.INSTANCE.put(in_).intValue();
                        msg_175=new Message[arraySize_176];
                        for(var forVar_177=0; forVar_177<arraySize_176; forVar_177++) {
                            msg_175[forVar_177]=Message.META.deserialize(serializeContextVar_150,in_);
                            
                        }
                        String[] argsNames_178 = new String[] {
                            "msg"
                        };
                        Object[] argsValues_179 = new Object[] {
                            msg_175
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("sendMessages", argsNames_178, argsValues_179);
                        localApi.sendMessages(msg_175);
                        serializeContextVar_150.invokeLocalMethodAfter("sendMessages", null, argsNames_178, argsValues_179);
                        break;
                        
                    }
                    case 8:  {
                        int requestId_180 = in_.readInt();
                        UUID owner_181;
                        UUID[] uids_182;
                        owner_181=FastMeta.META_UUID.deserialize(serializeContextVar_150,in_);
                        var arraySize_183 = DeserializerPackNumber.INSTANCE.put(in_).intValue();
                        uids_182=new UUID[arraySize_183];
                        for(var forVar_184=0; forVar_184<arraySize_183; forVar_184++) {
                            uids_182[forVar_184]=FastMeta.META_UUID.deserialize(serializeContextVar_150,in_);
                            
                        }
                        String[] argsNames_185 = new String[] {
                            "owner", "uids"
                        };
                        Object[] argsValues_186 = new Object[] {
                            owner_181, uids_182
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("createAccessGroup", argsNames_185, argsValues_186);
                        serializeContextVar_150.regLocalFuture();
                        var result_187 = localApi.createAccessGroup(owner_181,uids_182);
                        serializeContextVar_150.invokeLocalMethodAfter("createAccessGroup", result_187, argsNames_185, argsValues_186);
                        result_187.to((v_189)-> {
                            var data_188 = new DataInOut();
                            data_188.writeLong(v_189);
                            serializeContextVar_150.sendResultToRemote(requestId_180,data_188.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 9:  {
                        int requestId_190 = in_.readInt();
                        long groupId_191;
                        UUID uid_192;
                        groupId_191=in_.readLong();
                        uid_192=FastMeta.META_UUID.deserialize(serializeContextVar_150,in_);
                        String[] argsNames_193 = new String[] {
                            "groupId", "uid"
                        };
                        Object[] argsValues_194 = new Object[] {
                            groupId_191, uid_192
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("addToAccessGroup", argsNames_193, argsValues_194);
                        serializeContextVar_150.regLocalFuture();
                        var result_195 = localApi.addToAccessGroup(groupId_191,uid_192);
                        serializeContextVar_150.invokeLocalMethodAfter("addToAccessGroup", result_195, argsNames_193, argsValues_194);
                        result_195.to((v_197)-> {
                            var data_196 = new DataInOut();
                            data_196.writeByte(v_197?1:0);
                            serializeContextVar_150.sendResultToRemote(requestId_190,data_196.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 10:  {
                        int requestId_198 = in_.readInt();
                        long groupId_199;
                        UUID uid_200;
                        groupId_199=in_.readLong();
                        uid_200=FastMeta.META_UUID.deserialize(serializeContextVar_150,in_);
                        String[] argsNames_201 = new String[] {
                            "groupId", "uid"
                        };
                        Object[] argsValues_202 = new Object[] {
                            groupId_199, uid_200
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("removeFromAccessGroup", argsNames_201, argsValues_202);
                        serializeContextVar_150.regLocalFuture();
                        var result_203 = localApi.removeFromAccessGroup(groupId_199,uid_200);
                        serializeContextVar_150.invokeLocalMethodAfter("removeFromAccessGroup", result_203, argsNames_201, argsValues_202);
                        result_203.to((v_205)-> {
                            var data_204 = new DataInOut();
                            data_204.writeByte(v_205?1:0);
                            serializeContextVar_150.sendResultToRemote(requestId_198,data_204.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 11:  {
                        int requestId_206 = in_.readInt();
                        UUID uid_207;
                        uid_207=FastMeta.META_UUID.deserialize(serializeContextVar_150,in_);
                        String[] argsNames_208 = new String[] {
                            "uid"
                        };
                        Object[] argsValues_209 = new Object[] {
                            uid_207
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("checkAccessForSendMessage", argsNames_208, argsValues_209);
                        serializeContextVar_150.regLocalFuture();
                        var result_210 = localApi.checkAccessForSendMessage(uid_207);
                        serializeContextVar_150.invokeLocalMethodAfter("checkAccessForSendMessage", result_210, argsNames_208, argsValues_209);
                        result_210.to(()-> {
                            var data_211 = new DataInOut();
                            serializeContextVar_150.sendResultToRemote(requestId_206);
                            
                        }
                        );
                        break;
                        
                    }
                    case 12:  {
                        short[] sid_213;
                        var arraySize_214 = DeserializerPackNumber.INSTANCE.put(in_).intValue();
                        sid_213=new short[arraySize_214];
                        for(var forVar_215=0; forVar_215<arraySize_214; forVar_215++) {
                            sid_213[forVar_215]=in_.readShort();
                            
                        }
                        String[] argsNames_216 = new String[] {
                            "sid"
                        };
                        Object[] argsValues_217 = new Object[] {
                            sid_213
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("resolverServers", argsNames_216, argsValues_217);
                        localApi.resolverServers(sid_213);
                        serializeContextVar_150.invokeLocalMethodAfter("resolverServers", null, argsNames_216, argsValues_217);
                        break;
                        
                    }
                    case 13:  {
                        UUID[] uids_219;
                        var arraySize_220 = DeserializerPackNumber.INSTANCE.put(in_).intValue();
                        uids_219=new UUID[arraySize_220];
                        for(var forVar_221=0; forVar_221<arraySize_220; forVar_221++) {
                            uids_219[forVar_221]=FastMeta.META_UUID.deserialize(serializeContextVar_150,in_);
                            
                        }
                        String[] argsNames_222 = new String[] {
                            "uids"
                        };
                        Object[] argsValues_223 = new Object[] {
                            uids_219
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("resolverClouds", argsNames_222, argsValues_223);
                        localApi.resolverClouds(uids_219);
                        serializeContextVar_150.invokeLocalMethodAfter("resolverClouds", null, argsNames_222, argsValues_223);
                        break;
                        
                    }
                    case 14:  {
                        int requestId_224 = in_.readInt();
                        UUID uid_225;
                        uid_225=FastMeta.META_UUID.deserialize(serializeContextVar_150,in_);
                        String[] argsNames_226 = new String[] {
                            "uid"
                        };
                        Object[] argsValues_227 = new Object[] {
                            uid_225
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("getAccessGroups", argsNames_226, argsValues_227);
                        serializeContextVar_150.regLocalFuture();
                        var result_228 = localApi.getAccessGroups(uid_225);
                        serializeContextVar_150.invokeLocalMethodAfter("getAccessGroups", result_228, argsNames_226, argsValues_227);
                        result_228.to((v_230)-> {
                            var data_229 = new DataInOut();
                            SerializerPackNumber.INSTANCE.put(data_229,v_230.length);
                            for(var forVar_231:v_230) {
                                data_229.writeLong(forVar_231);
                                
                            }
                            serializeContextVar_150.sendResultToRemote(requestId_224,data_229.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 15:  {
                        int requestId_232 = in_.readInt();
                        long groupId_233;
                        groupId_233=in_.readLong();
                        String[] argsNames_234 = new String[] {
                            "groupId"
                        };
                        Object[] argsValues_235 = new Object[] {
                            groupId_233
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("getAccessGroup", argsNames_234, argsValues_235);
                        serializeContextVar_150.regLocalFuture();
                        var result_236 = localApi.getAccessGroup(groupId_233);
                        serializeContextVar_150.invokeLocalMethodAfter("getAccessGroup", result_236, argsNames_234, argsValues_235);
                        result_236.to((v_238)-> {
                            var data_237 = new DataInOut();
                            AccessGroup.META.serialize(serializeContextVar_150,v_238,data_237);
                            serializeContextVar_150.sendResultToRemote(requestId_232,data_237.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 16:  {
                        int requestId_239 = in_.readInt();
                        UUID uid_240;
                        uid_240=FastMeta.META_UUID.deserialize(serializeContextVar_150,in_);
                        String[] argsNames_241 = new String[] {
                            "uid"
                        };
                        Object[] argsValues_242 = new Object[] {
                            uid_240
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("getAllAccessedClients", argsNames_241, argsValues_242);
                        serializeContextVar_150.regLocalFuture();
                        var result_243 = localApi.getAllAccessedClients(uid_240);
                        serializeContextVar_150.invokeLocalMethodAfter("getAllAccessedClients", result_243, argsNames_241, argsValues_242);
                        result_243.to((v_245)-> {
                            var data_244 = new DataInOut();
                            SerializerPackNumber.INSTANCE.put(data_244,v_245.length);
                            for(var forVar_246:v_245) {
                                FastMeta.META_UUID.serialize(serializeContextVar_150,forVar_246,data_244);
                                
                            }
                            serializeContextVar_150.sendResultToRemote(requestId_239,data_244.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 17:  {
                        int requestId_247 = in_.readInt();
                        UUID uid1_248;
                        UUID uid2_249;
                        uid1_248=FastMeta.META_UUID.deserialize(serializeContextVar_150,in_);
                        uid2_249=FastMeta.META_UUID.deserialize(serializeContextVar_150,in_);
                        String[] argsNames_250 = new String[] {
                            "uid1", "uid2"
                        };
                        Object[] argsValues_251 = new Object[] {
                            uid1_248, uid2_249
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("checkAccessForSendMessage2", argsNames_250, argsValues_251);
                        serializeContextVar_150.regLocalFuture();
                        var result_252 = localApi.checkAccessForSendMessage2(uid1_248,uid2_249);
                        serializeContextVar_150.invokeLocalMethodAfter("checkAccessForSendMessage2", result_252, argsNames_250, argsValues_251);
                        result_252.to((v_254)-> {
                            var data_253 = new DataInOut();
                            data_253.writeByte(v_254?1:0);
                            serializeContextVar_150.sendResultToRemote(requestId_247,data_253.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 18:  {
                        Telemetry telemetry_256;
                        telemetry_256=Telemetry.META.deserialize(serializeContextVar_150,in_);
                        String[] argsNames_257 = new String[] {
                            "telemetry"
                        };
                        Object[] argsValues_258 = new Object[] {
                            telemetry_256
                        };
                        serializeContextVar_150.invokeLocalMethodBefore("sendTelemetry", argsNames_257, argsValues_258);
                        localApi.sendTelemetry(telemetry_256);
                        serializeContextVar_150.invokeLocalMethodAfter("sendTelemetry", null, argsNames_257, argsValues_258);
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public AuthorizedApiRemote makeRemote(FastFutureContext localApi_260) {
            return new AuthorizedApiRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_260.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_260;
                    
                }
                @Override public @Command(3) void backId(byte id) {
                    var dataOut_261 = new DataInOut();
                    dataOut_261.writeByte(3);
                    String[] argsNames_263 = new String[] {
                        "id"
                    };
                    Object[] argsValues_264 = new Object[] {
                        id
                    };
                    localApi_260.invokeRemoteMethodAfter("backId", null, argsNames_263, argsValues_264);
                    dataOut_261.writeByte(id);
                    localApi_260.sendToRemote(dataOut_261.toArray());
                    
                }
                @Override public @Command(4) AFuture ping(long nextConnectMsDuration) {
                    var dataOut_265 = new DataInOut();
                    dataOut_265.writeByte(4);
                    String[] argsNames_267 = new String[] {
                        "nextConnectMsDuration"
                    };
                    Object[] argsValues_268 = new Object[] {
                        nextConnectMsDuration
                    };
                    var result_266 = AFuture.make();
                    localApi_260.invokeRemoteMethodAfter("ping", result_266, argsNames_267, argsValues_268);
                    var requestId_269 = localApi_260.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_266.done();
                            
                        }
                        public void onError(DataIn in) {
                            result_266.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_265.writeInt(requestId_269);
                    dataOut_265.writeLong(nextConnectMsDuration);
                    localApi_260.sendToRemote(dataOut_265.toArray());
                    return result_266;
                    
                }
                @Override public @Command(5) void client(UUID uid, ClientApiStream stream) {
                    var dataOut_270 = new DataInOut();
                    dataOut_270.writeByte(5);
                    String[] argsNames_272 = new String[] {
                        "uid", "stream"
                    };
                    Object[] argsValues_273 = new Object[] {
                        uid, stream
                    };
                    localApi_260.invokeRemoteMethodAfter("client", null, argsNames_272, argsValues_273);
                    FastMeta.META_UUID.serialize(localApi_260,uid,dataOut_270);
                    ClientApiStream.META.serialize(localApi_260,stream,dataOut_270);
                    localApi_260.sendToRemote(dataOut_270.toArray());
                    
                }
                @Override public @Command(6) void sendMessage(Message msg) {
                    var dataOut_274 = new DataInOut();
                    dataOut_274.writeByte(6);
                    String[] argsNames_276 = new String[] {
                        "msg"
                    };
                    Object[] argsValues_277 = new Object[] {
                        msg
                    };
                    localApi_260.invokeRemoteMethodAfter("sendMessage", null, argsNames_276, argsValues_277);
                    Message.META.serialize(localApi_260,msg,dataOut_274);
                    localApi_260.sendToRemote(dataOut_274.toArray());
                    
                }
                @Override public @Command(7) void sendMessages(Message[] msg) {
                    var dataOut_278 = new DataInOut();
                    dataOut_278.writeByte(7);
                    String[] argsNames_280 = new String[] {
                        "msg"
                    };
                    Object[] argsValues_281 = new Object[] {
                        msg
                    };
                    localApi_260.invokeRemoteMethodAfter("sendMessages", null, argsNames_280, argsValues_281);
                    SerializerPackNumber.INSTANCE.put(dataOut_278,msg.length);
                    for(var forVar_282:msg) {
                        Message.META.serialize(localApi_260,forVar_282,dataOut_278);
                        
                    }
                    localApi_260.sendToRemote(dataOut_278.toArray());
                    
                }
                @Override public @Command(8) ARFuture<Long> createAccessGroup(UUID owner, UUID[] uids) {
                    var dataOut_283 = new DataInOut();
                    dataOut_283.writeByte(8);
                    String[] argsNames_285 = new String[] {
                        "owner", "uids"
                    };
                    Object[] argsValues_286 = new Object[] {
                        owner, uids
                    };
                    var result_284 = ARFuture.<Long>of();
                    localApi_260.invokeRemoteMethodAfter("createAccessGroup", result_284, argsNames_285, argsValues_286);
                    var requestId_287 = localApi_260.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_284.done(FastMeta.META_LONG.deserialize(localApi_260,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_284.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_283.writeInt(requestId_287);
                    FastMeta.META_UUID.serialize(localApi_260,owner,dataOut_283);
                    SerializerPackNumber.INSTANCE.put(dataOut_283,uids.length);
                    for(var forVar_288:uids) {
                        FastMeta.META_UUID.serialize(localApi_260,forVar_288,dataOut_283);
                        
                    }
                    localApi_260.sendToRemote(dataOut_283.toArray());
                    return result_284;
                    
                }
                @Override public @Command(9) ARFuture<Boolean> addToAccessGroup(long groupId, UUID uid) {
                    var dataOut_289 = new DataInOut();
                    dataOut_289.writeByte(9);
                    String[] argsNames_291 = new String[] {
                        "groupId", "uid"
                    };
                    Object[] argsValues_292 = new Object[] {
                        groupId, uid
                    };
                    var result_290 = ARFuture.<Boolean>of();
                    localApi_260.invokeRemoteMethodAfter("addToAccessGroup", result_290, argsNames_291, argsValues_292);
                    var requestId_293 = localApi_260.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_290.done(FastMeta.META_BOOLEAN.deserialize(localApi_260,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_290.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_289.writeInt(requestId_293);
                    dataOut_289.writeLong(groupId);
                    FastMeta.META_UUID.serialize(localApi_260,uid,dataOut_289);
                    localApi_260.sendToRemote(dataOut_289.toArray());
                    return result_290;
                    
                }
                @Override public @Command(10) ARFuture<Boolean> removeFromAccessGroup(long groupId, UUID uid) {
                    var dataOut_294 = new DataInOut();
                    dataOut_294.writeByte(10);
                    String[] argsNames_296 = new String[] {
                        "groupId", "uid"
                    };
                    Object[] argsValues_297 = new Object[] {
                        groupId, uid
                    };
                    var result_295 = ARFuture.<Boolean>of();
                    localApi_260.invokeRemoteMethodAfter("removeFromAccessGroup", result_295, argsNames_296, argsValues_297);
                    var requestId_298 = localApi_260.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_295.done(FastMeta.META_BOOLEAN.deserialize(localApi_260,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_295.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_294.writeInt(requestId_298);
                    dataOut_294.writeLong(groupId);
                    FastMeta.META_UUID.serialize(localApi_260,uid,dataOut_294);
                    localApi_260.sendToRemote(dataOut_294.toArray());
                    return result_295;
                    
                }
                @Override public @Command(11) AFuture checkAccessForSendMessage(UUID uid) {
                    var dataOut_299 = new DataInOut();
                    dataOut_299.writeByte(11);
                    String[] argsNames_301 = new String[] {
                        "uid"
                    };
                    Object[] argsValues_302 = new Object[] {
                        uid
                    };
                    var result_300 = AFuture.make();
                    localApi_260.invokeRemoteMethodAfter("checkAccessForSendMessage", result_300, argsNames_301, argsValues_302);
                    var requestId_303 = localApi_260.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_300.done();
                            
                        }
                        public void onError(DataIn in) {
                            result_300.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_299.writeInt(requestId_303);
                    FastMeta.META_UUID.serialize(localApi_260,uid,dataOut_299);
                    localApi_260.sendToRemote(dataOut_299.toArray());
                    return result_300;
                    
                }
                @Override public @Command(12) void resolverServers(short[] sid) {
                    var dataOut_304 = new DataInOut();
                    dataOut_304.writeByte(12);
                    String[] argsNames_306 = new String[] {
                        "sid"
                    };
                    Object[] argsValues_307 = new Object[] {
                        sid
                    };
                    localApi_260.invokeRemoteMethodAfter("resolverServers", null, argsNames_306, argsValues_307);
                    SerializerPackNumber.INSTANCE.put(dataOut_304,sid.length);
                    for(var forVar_308:sid) {
                        dataOut_304.writeShort(forVar_308);
                        
                    }
                    localApi_260.sendToRemote(dataOut_304.toArray());
                    
                }
                @Override public @Command(13) void resolverClouds(UUID[] uids) {
                    var dataOut_309 = new DataInOut();
                    dataOut_309.writeByte(13);
                    String[] argsNames_311 = new String[] {
                        "uids"
                    };
                    Object[] argsValues_312 = new Object[] {
                        uids
                    };
                    localApi_260.invokeRemoteMethodAfter("resolverClouds", null, argsNames_311, argsValues_312);
                    SerializerPackNumber.INSTANCE.put(dataOut_309,uids.length);
                    for(var forVar_313:uids) {
                        FastMeta.META_UUID.serialize(localApi_260,forVar_313,dataOut_309);
                        
                    }
                    localApi_260.sendToRemote(dataOut_309.toArray());
                    
                }
                @Override public @Command(14) ARFuture<long[]> getAccessGroups(UUID uid) {
                    var dataOut_314 = new DataInOut();
                    dataOut_314.writeByte(14);
                    String[] argsNames_316 = new String[] {
                        "uid"
                    };
                    Object[] argsValues_317 = new Object[] {
                        uid
                    };
                    var result_315 = ARFuture.<long[]>of();
                    localApi_260.invokeRemoteMethodAfter("getAccessGroups", result_315, argsNames_316, argsValues_317);
                    var requestId_318 = localApi_260.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_315.done(FastMeta.META_ARRAY_LONG.deserialize(localApi_260,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_315.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_314.writeInt(requestId_318);
                    FastMeta.META_UUID.serialize(localApi_260,uid,dataOut_314);
                    localApi_260.sendToRemote(dataOut_314.toArray());
                    return result_315;
                    
                }
                @Override public @Command(15) ARFuture<AccessGroup> getAccessGroup(long groupId) {
                    var dataOut_319 = new DataInOut();
                    dataOut_319.writeByte(15);
                    String[] argsNames_321 = new String[] {
                        "groupId"
                    };
                    Object[] argsValues_322 = new Object[] {
                        groupId
                    };
                    var result_320 = ARFuture.<AccessGroup>of();
                    localApi_260.invokeRemoteMethodAfter("getAccessGroup", result_320, argsNames_321, argsValues_322);
                    var requestId_323 = localApi_260.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_320.done(AccessGroup.META.deserialize(localApi_260,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_320.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_319.writeInt(requestId_323);
                    dataOut_319.writeLong(groupId);
                    localApi_260.sendToRemote(dataOut_319.toArray());
                    return result_320;
                    
                }
                @Override public @Command(16) ARFuture<UUID[]> getAllAccessedClients(UUID uid) {
                    var dataOut_324 = new DataInOut();
                    dataOut_324.writeByte(16);
                    String[] argsNames_326 = new String[] {
                        "uid"
                    };
                    Object[] argsValues_327 = new Object[] {
                        uid
                    };
                    var result_325 = ARFuture.<UUID[]>of();
                    localApi_260.invokeRemoteMethodAfter("getAllAccessedClients", result_325, argsNames_326, argsValues_327);
                    var requestId_328 = localApi_260.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_325.done(FastMeta.META_ARRAY_UUID.deserialize(localApi_260,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_325.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_324.writeInt(requestId_328);
                    FastMeta.META_UUID.serialize(localApi_260,uid,dataOut_324);
                    localApi_260.sendToRemote(dataOut_324.toArray());
                    return result_325;
                    
                }
                @Override public @Command(17) ARFuture<Boolean> checkAccessForSendMessage2(UUID uid1, UUID uid2) {
                    var dataOut_329 = new DataInOut();
                    dataOut_329.writeByte(17);
                    String[] argsNames_331 = new String[] {
                        "uid1", "uid2"
                    };
                    Object[] argsValues_332 = new Object[] {
                        uid1, uid2
                    };
                    var result_330 = ARFuture.<Boolean>of();
                    localApi_260.invokeRemoteMethodAfter("checkAccessForSendMessage2", result_330, argsNames_331, argsValues_332);
                    var requestId_333 = localApi_260.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_330.done(FastMeta.META_BOOLEAN.deserialize(localApi_260,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_330.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_329.writeInt(requestId_333);
                    FastMeta.META_UUID.serialize(localApi_260,uid1,dataOut_329);
                    FastMeta.META_UUID.serialize(localApi_260,uid2,dataOut_329);
                    localApi_260.sendToRemote(dataOut_329.toArray());
                    return result_330;
                    
                }
                @Override public @Command(18) void sendTelemetry(Telemetry telemetry) {
                    var dataOut_334 = new DataInOut();
                    dataOut_334.writeByte(18);
                    String[] argsNames_336 = new String[] {
                        "telemetry"
                    };
                    Object[] argsValues_337 = new Object[] {
                        telemetry
                    };
                    localApi_260.invokeRemoteMethodAfter("sendTelemetry", null, argsNames_336, argsValues_337);
                    Telemetry.META.serialize(localApi_260,telemetry,dataOut_334);
                    localApi_260.sendToRemote(dataOut_334.toArray());
                    
                }
                
            };
            
        }
        
    };
    @Command(3) void backId(byte id);
    @Command(4) AFuture ping(long nextConnectMsDuration);
    @Command(5) void client(UUID uid, ClientApiStream stream);
    @Command(6) void sendMessage(Message msg);
    @Command(7) void sendMessages(Message[] msg);
    @Command(8) ARFuture<Long> createAccessGroup(UUID owner, UUID[] uids);
    @Command(9) ARFuture<Boolean> addToAccessGroup(long groupId, UUID uid);
    @Command(10) ARFuture<Boolean> removeFromAccessGroup(long groupId, UUID uid);
    @Command(11) AFuture checkAccessForSendMessage(UUID uid);
    @Command(12) void resolverServers(short[] sid);
    @Command(13) void resolverClouds(UUID[] uids);
    @Command(14) ARFuture<long[]> getAccessGroups(UUID uid);
    @Command(15) ARFuture<AccessGroup> getAccessGroup(long groupId);
    @Command(16) ARFuture<UUID[]> getAllAccessedClients(UUID uid);
    @Command(17) ARFuture<Boolean> checkAccessForSendMessage2(UUID uid1, UUID uid2);
    @Command(18) void sendTelemetry(Telemetry telemetry);
    
}

=== Файл: AuthorizedApiLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class AuthorizedApiLocal<RT> implements AuthorizedApi {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected AuthorizedApiLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: AuthorizedApiRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface AuthorizedApiRemote extends AuthorizedApi, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: ClientApiRegSafe.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ClientApiRegSafe  {
    ClientApiRegSafe EMPTY=new ClientApiRegSafe() {
        
    };
    FastMetaApi<ClientApiRegSafe,ClientApiRegSafeRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_0, DataIn in_, ClientApiRegSafe localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_1 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_0,in_);
                        var futureRec_2 = serializeContextVar_0.getFuture(requestId_1);
                        if(futureRec_2 != null) futureRec_2.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_3 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_0,in_);
                        var futureRec_4 = serializeContextVar_0.getFuture(requestId_3);
                        if(futureRec_4 != null) futureRec_4.onError(in_);
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public ClientApiRegSafeRemote makeRemote(FastFutureContext localApi_6) {
            return new ClientApiRegSafeRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_6.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_6;
                    
                }
                
            };
            
        }
        
    };
    
}

=== Файл: ClientApiRegSafeLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class ClientApiRegSafeLocal<RT> implements ClientApiRegSafe {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected ClientApiRegSafeLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: ClientApiRegSafeRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ClientApiRegSafeRemote extends ClientApiRegSafe, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: ClientApiRegSafeStream.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public class ClientApiRegSafeStream implements io.aether.utils.ToString  {
    public static final FastMetaType<ClientApiRegSafeStream> META = new FastMetaType<>()  {
        @Override public void serialize(FastFutureContext ctx, ClientApiRegSafeStream obj, DataOut out)  {
            FastMeta.META_ARRAY_BYTE.serialize(ctx, obj.data, out);
            
        }
        @Override public ClientApiRegSafeStream deserialize(FastFutureContext ctx, DataIn in)  {
            return new ClientApiRegSafeStream(FastMeta.META_ARRAY_BYTE.deserialize(ctx, in));
            
        }
        
    };
    public final byte[] data;
    public ClientApiRegSafeStream(byte[] data)  {
        this.data = data;
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("ClientApiRegSafeStream(");
        sb.add("data[").add(this.data.length).add("]:").add(this.data);
        sb.add(')');
        
    }
    public void accept(FastFutureContext context, BytesConverter provider, ClientApiRegSafe localApi)  {
        byte[] decryptedData = provider.apply(this.data);
        ClientApiRegSafe.META.makeLocal(context, new DataInOutStatic(decryptedData), localApi);
        
    }
    public void accept(FastApiContextLocal<? extends ClientApiRegSafe> context, BytesConverter provider)  {
        accept(context, provider, context.localApi);
        
    }
    public void accept(BytesConverter provider, ClientApiRegSafe localApi)  {
        accept(((FastFutureContextGetter)localApi).getFastFutureContext(),provider,localApi);
        
    }
    public ClientApiRegSafeStream(FastFutureContext context,BytesConverter provider, io.aether.net.fastMeta.RemoteApiFuture<ClientApiRegSafeRemote> remote, AFuture sendFuture)  {
        remote.executeAll(context, sendFuture);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public ClientApiRegSafeStream(FastFutureContext context,BytesConverter provider, AConsumer<ClientApiRegSafeRemote> remote)  {
        var api= ClientApiRegSafe.META.makeRemote(context);
        remote.accept(api);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public ClientApiRegSafeStream(BytesConverter provider, byte[] remoteData)  {
        this.data=provider.apply(remoteData);
        
    }
    public ClientApiRegSafeStream(FastFutureContextGetter context,BytesConverter provider, AConsumer<ClientApiRegSafeRemote> remote)  {
        this(context.getFastFutureContext(),provider, remote);
        
    }
    
}

=== Файл: ClientApiRegUnsafe.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ClientApiRegUnsafe  {
    FastMetaApi<ClientApiRegUnsafe,ClientApiRegUnsafeRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_14, DataIn in_, ClientApiRegUnsafe localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_15 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_14,in_);
                        var futureRec_16 = serializeContextVar_14.getFuture(requestId_15);
                        if(futureRec_16 != null) futureRec_16.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_17 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_14,in_);
                        var futureRec_18 = serializeContextVar_14.getFuture(requestId_17);
                        if(futureRec_18 != null) futureRec_18.onError(in_);
                        break;
                        
                    }
                    case 3:  {
                        ClientApiRegSafeStream stream_20;
                        stream_20=ClientApiRegSafeStream.META.deserialize(serializeContextVar_14,in_);
                        String[] argsNames_21 = new String[] {
                            "stream"
                        };
                        Object[] argsValues_22 = new Object[] {
                            stream_20
                        };
                        serializeContextVar_14.invokeLocalMethodBefore("enter", argsNames_21, argsValues_22);
                        localApi.enter(stream_20);
                        serializeContextVar_14.invokeLocalMethodAfter("enter", null, argsNames_21, argsValues_22);
                        break;
                        
                    }
                    case 4:  {
                        GlobalRegClientApiStream stream_24;
                        stream_24=GlobalRegClientApiStream.META.deserialize(serializeContextVar_14,in_);
                        String[] argsNames_25 = new String[] {
                            "stream"
                        };
                        Object[] argsValues_26 = new Object[] {
                            stream_24
                        };
                        serializeContextVar_14.invokeLocalMethodBefore("enterGlobal", argsNames_25, argsValues_26);
                        localApi.enterGlobal(stream_24);
                        serializeContextVar_14.invokeLocalMethodAfter("enterGlobal", null, argsNames_25, argsValues_26);
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public ClientApiRegUnsafeRemote makeRemote(FastFutureContext localApi_28) {
            return new ClientApiRegUnsafeRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_28.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_28;
                    
                }
                @Override public @Command(3) void enter(ClientApiRegSafeStream stream) {
                    var dataOut_29 = new DataInOut();
                    dataOut_29.writeByte(3);
                    String[] argsNames_31 = new String[] {
                        "stream"
                    };
                    Object[] argsValues_32 = new Object[] {
                        stream
                    };
                    localApi_28.invokeRemoteMethodAfter("enter", null, argsNames_31, argsValues_32);
                    ClientApiRegSafeStream.META.serialize(localApi_28,stream,dataOut_29);
                    localApi_28.sendToRemote(dataOut_29.toArray());
                    
                }
                @Override public @Command(4) void enterGlobal(GlobalRegClientApiStream stream) {
                    var dataOut_33 = new DataInOut();
                    dataOut_33.writeByte(4);
                    String[] argsNames_35 = new String[] {
                        "stream"
                    };
                    Object[] argsValues_36 = new Object[] {
                        stream
                    };
                    localApi_28.invokeRemoteMethodAfter("enterGlobal", null, argsNames_35, argsValues_36);
                    GlobalRegClientApiStream.META.serialize(localApi_28,stream,dataOut_33);
                    localApi_28.sendToRemote(dataOut_33.toArray());
                    
                }
                
            };
            
        }
        
    };
    @Command(3) void enter(ClientApiRegSafeStream stream);
    @Command(4) void enterGlobal(GlobalRegClientApiStream stream);
    
}

=== Файл: ClientApiRegUnsafeLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class ClientApiRegUnsafeLocal<RT> implements ClientApiRegUnsafe {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected ClientApiRegUnsafeLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: ClientApiRegUnsafeRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ClientApiRegUnsafeRemote extends ClientApiRegUnsafe, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: ClientApiSafe.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ClientApiSafe  {
    FastMetaApi<ClientApiSafe,ClientApiSafeRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_62, DataIn in_, ClientApiSafe localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_63 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_62,in_);
                        var futureRec_64 = serializeContextVar_62.getFuture(requestId_63);
                        if(futureRec_64 != null) futureRec_64.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_65 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_62,in_);
                        var futureRec_66 = serializeContextVar_62.getFuture(requestId_65);
                        if(futureRec_66 != null) futureRec_66.onError(in_);
                        break;
                        
                    }
                    case 3:  {
                        UUID uid_68;
                        uid_68=FastMeta.META_UUID.deserialize(serializeContextVar_62,in_);
                        String[] argsNames_69 = new String[] {
                            "uid"
                        };
                        Object[] argsValues_70 = new Object[] {
                            uid_68
                        };
                        serializeContextVar_62.invokeLocalMethodBefore("changeParent", argsNames_69, argsValues_70);
                        localApi.changeParent(uid_68);
                        serializeContextVar_62.invokeLocalMethodAfter("changeParent", null, argsNames_69, argsValues_70);
                        break;
                        
                    }
                    case 4:  {
                        UUID alias_72;
                        alias_72=FastMeta.META_UUID.deserialize(serializeContextVar_62,in_);
                        String[] argsNames_73 = new String[] {
                            "alias"
                        };
                        Object[] argsValues_74 = new Object[] {
                            alias_72
                        };
                        serializeContextVar_62.invokeLocalMethodBefore("changeAlias", argsNames_73, argsValues_74);
                        localApi.changeAlias(alias_72);
                        serializeContextVar_62.invokeLocalMethodAfter("changeAlias", null, argsNames_73, argsValues_74);
                        break;
                        
                    }
                    case 5:  {
                        UUID uid_76;
                        uid_76=FastMeta.META_UUID.deserialize(serializeContextVar_62,in_);
                        String[] argsNames_77 = new String[] {
                            "uid"
                        };
                        Object[] argsValues_78 = new Object[] {
                            uid_76
                        };
                        serializeContextVar_62.invokeLocalMethodBefore("newChild", argsNames_77, argsValues_78);
                        localApi.newChild(uid_76);
                        serializeContextVar_62.invokeLocalMethodAfter("newChild", null, argsNames_77, argsValues_78);
                        break;
                        
                    }
                    case 6:  {
                        Message[] msg_80;
                        var arraySize_81 = DeserializerPackNumber.INSTANCE.put(in_).intValue();
                        msg_80=new Message[arraySize_81];
                        for(var forVar_82=0; forVar_82<arraySize_81; forVar_82++) {
                            msg_80[forVar_82]=Message.META.deserialize(serializeContextVar_62,in_);
                            
                        }
                        String[] argsNames_83 = new String[] {
                            "msg"
                        };
                        Object[] argsValues_84 = new Object[] {
                            msg_80
                        };
                        serializeContextVar_62.invokeLocalMethodBefore("sendMessages", argsNames_83, argsValues_84);
                        localApi.sendMessages(msg_80);
                        serializeContextVar_62.invokeLocalMethodAfter("sendMessages", null, argsNames_83, argsValues_84);
                        break;
                        
                    }
                    case 7:  {
                        ServerDescriptor serverDescriptor_86;
                        serverDescriptor_86=ServerDescriptor.META.deserialize(serializeContextVar_62,in_);
                        String[] argsNames_87 = new String[] {
                            "serverDescriptor"
                        };
                        Object[] argsValues_88 = new Object[] {
                            serverDescriptor_86
                        };
                        serializeContextVar_62.invokeLocalMethodBefore("sendServerDescriptor", argsNames_87, argsValues_88);
                        localApi.sendServerDescriptor(serverDescriptor_86);
                        serializeContextVar_62.invokeLocalMethodAfter("sendServerDescriptor", null, argsNames_87, argsValues_88);
                        break;
                        
                    }
                    case 8:  {
                        ServerDescriptor[] serverDescriptors_90;
                        var arraySize_91 = DeserializerPackNumber.INSTANCE.put(in_).intValue();
                        serverDescriptors_90=new ServerDescriptor[arraySize_91];
                        for(var forVar_92=0; forVar_92<arraySize_91; forVar_92++) {
                            serverDescriptors_90[forVar_92]=ServerDescriptor.META.deserialize(serializeContextVar_62,in_);
                            
                        }
                        String[] argsNames_93 = new String[] {
                            "serverDescriptors"
                        };
                        Object[] argsValues_94 = new Object[] {
                            serverDescriptors_90
                        };
                        serializeContextVar_62.invokeLocalMethodBefore("sendServerDescriptors", argsNames_93, argsValues_94);
                        localApi.sendServerDescriptors(serverDescriptors_90);
                        serializeContextVar_62.invokeLocalMethodAfter("sendServerDescriptors", null, argsNames_93, argsValues_94);
                        break;
                        
                    }
                    case 9:  {
                        UUID uid_96;
                        Cloud cloud_97;
                        uid_96=FastMeta.META_UUID.deserialize(serializeContextVar_62,in_);
                        cloud_97=Cloud.META.deserialize(serializeContextVar_62,in_);
                        String[] argsNames_98 = new String[] {
                            "uid", "cloud"
                        };
                        Object[] argsValues_99 = new Object[] {
                            uid_96, cloud_97
                        };
                        serializeContextVar_62.invokeLocalMethodBefore("sendCloud", argsNames_98, argsValues_99);
                        localApi.sendCloud(uid_96,cloud_97);
                        serializeContextVar_62.invokeLocalMethodAfter("sendCloud", null, argsNames_98, argsValues_99);
                        break;
                        
                    }
                    case 10:  {
                        UUIDAndCloud[] clouds_101;
                        var arraySize_102 = DeserializerPackNumber.INSTANCE.put(in_).intValue();
                        clouds_101=new UUIDAndCloud[arraySize_102];
                        for(var forVar_103=0; forVar_103<arraySize_102; forVar_103++) {
                            clouds_101[forVar_103]=UUIDAndCloud.META.deserialize(serializeContextVar_62,in_);
                            
                        }
                        String[] argsNames_104 = new String[] {
                            "clouds"
                        };
                        Object[] argsValues_105 = new Object[] {
                            clouds_101
                        };
                        serializeContextVar_62.invokeLocalMethodBefore("sendClouds", argsNames_104, argsValues_105);
                        localApi.sendClouds(clouds_101);
                        serializeContextVar_62.invokeLocalMethodAfter("sendClouds", null, argsNames_104, argsValues_105);
                        break;
                        
                    }
                    case 11:  {
                        String[] argsNames_107 = new String[] {
                            
                        };
                        Object[] argsValues_108 = new Object[] {
                            
                        };
                        serializeContextVar_62.invokeLocalMethodBefore("requestTelemetry", argsNames_107, argsValues_108);
                        localApi.requestTelemetry();
                        serializeContextVar_62.invokeLocalMethodAfter("requestTelemetry", null, argsNames_107, argsValues_108);
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public ClientApiSafeRemote makeRemote(FastFutureContext localApi_110) {
            return new ClientApiSafeRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_110.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_110;
                    
                }
                @Override public @Command(3) void changeParent(UUID uid) {
                    var dataOut_111 = new DataInOut();
                    dataOut_111.writeByte(3);
                    String[] argsNames_113 = new String[] {
                        "uid"
                    };
                    Object[] argsValues_114 = new Object[] {
                        uid
                    };
                    localApi_110.invokeRemoteMethodAfter("changeParent", null, argsNames_113, argsValues_114);
                    FastMeta.META_UUID.serialize(localApi_110,uid,dataOut_111);
                    localApi_110.sendToRemote(dataOut_111.toArray());
                    
                }
                @Override public @Command(4) void changeAlias(UUID alias) {
                    var dataOut_115 = new DataInOut();
                    dataOut_115.writeByte(4);
                    String[] argsNames_117 = new String[] {
                        "alias"
                    };
                    Object[] argsValues_118 = new Object[] {
                        alias
                    };
                    localApi_110.invokeRemoteMethodAfter("changeAlias", null, argsNames_117, argsValues_118);
                    FastMeta.META_UUID.serialize(localApi_110,alias,dataOut_115);
                    localApi_110.sendToRemote(dataOut_115.toArray());
                    
                }
                @Override public @Command(5) void newChild(UUID uid) {
                    var dataOut_119 = new DataInOut();
                    dataOut_119.writeByte(5);
                    String[] argsNames_121 = new String[] {
                        "uid"
                    };
                    Object[] argsValues_122 = new Object[] {
                        uid
                    };
                    localApi_110.invokeRemoteMethodAfter("newChild", null, argsNames_121, argsValues_122);
                    FastMeta.META_UUID.serialize(localApi_110,uid,dataOut_119);
                    localApi_110.sendToRemote(dataOut_119.toArray());
                    
                }
                @Override public @Command(6) void sendMessages(Message[] msg) {
                    var dataOut_123 = new DataInOut();
                    dataOut_123.writeByte(6);
                    String[] argsNames_125 = new String[] {
                        "msg"
                    };
                    Object[] argsValues_126 = new Object[] {
                        msg
                    };
                    localApi_110.invokeRemoteMethodAfter("sendMessages", null, argsNames_125, argsValues_126);
                    SerializerPackNumber.INSTANCE.put(dataOut_123,msg.length);
                    for(var forVar_127:msg) {
                        Message.META.serialize(localApi_110,forVar_127,dataOut_123);
                        
                    }
                    localApi_110.sendToRemote(dataOut_123.toArray());
                    
                }
                @Override public @Command(7) void sendServerDescriptor(ServerDescriptor serverDescriptor) {
                    var dataOut_128 = new DataInOut();
                    dataOut_128.writeByte(7);
                    String[] argsNames_130 = new String[] {
                        "serverDescriptor"
                    };
                    Object[] argsValues_131 = new Object[] {
                        serverDescriptor
                    };
                    localApi_110.invokeRemoteMethodAfter("sendServerDescriptor", null, argsNames_130, argsValues_131);
                    ServerDescriptor.META.serialize(localApi_110,serverDescriptor,dataOut_128);
                    localApi_110.sendToRemote(dataOut_128.toArray());
                    
                }
                @Override public @Command(8) void sendServerDescriptors(ServerDescriptor[] serverDescriptors) {
                    var dataOut_132 = new DataInOut();
                    dataOut_132.writeByte(8);
                    String[] argsNames_134 = new String[] {
                        "serverDescriptors"
                    };
                    Object[] argsValues_135 = new Object[] {
                        serverDescriptors
                    };
                    localApi_110.invokeRemoteMethodAfter("sendServerDescriptors", null, argsNames_134, argsValues_135);
                    SerializerPackNumber.INSTANCE.put(dataOut_132,serverDescriptors.length);
                    for(var forVar_136:serverDescriptors) {
                        ServerDescriptor.META.serialize(localApi_110,forVar_136,dataOut_132);
                        
                    }
                    localApi_110.sendToRemote(dataOut_132.toArray());
                    
                }
                @Override public @Command(9) void sendCloud(UUID uid, Cloud cloud) {
                    var dataOut_137 = new DataInOut();
                    dataOut_137.writeByte(9);
                    String[] argsNames_139 = new String[] {
                        "uid", "cloud"
                    };
                    Object[] argsValues_140 = new Object[] {
                        uid, cloud
                    };
                    localApi_110.invokeRemoteMethodAfter("sendCloud", null, argsNames_139, argsValues_140);
                    FastMeta.META_UUID.serialize(localApi_110,uid,dataOut_137);
                    Cloud.META.serialize(localApi_110,cloud,dataOut_137);
                    localApi_110.sendToRemote(dataOut_137.toArray());
                    
                }
                @Override public @Command(10) void sendClouds(UUIDAndCloud[] clouds) {
                    var dataOut_141 = new DataInOut();
                    dataOut_141.writeByte(10);
                    String[] argsNames_143 = new String[] {
                        "clouds"
                    };
                    Object[] argsValues_144 = new Object[] {
                        clouds
                    };
                    localApi_110.invokeRemoteMethodAfter("sendClouds", null, argsNames_143, argsValues_144);
                    SerializerPackNumber.INSTANCE.put(dataOut_141,clouds.length);
                    for(var forVar_145:clouds) {
                        UUIDAndCloud.META.serialize(localApi_110,forVar_145,dataOut_141);
                        
                    }
                    localApi_110.sendToRemote(dataOut_141.toArray());
                    
                }
                @Override public @Command(11) void requestTelemetry() {
                    var dataOut_146 = new DataInOut();
                    dataOut_146.writeByte(11);
                    String[] argsNames_148 = new String[] {
                        
                    };
                    Object[] argsValues_149 = new Object[] {
                        
                    };
                    localApi_110.invokeRemoteMethodAfter("requestTelemetry", null, argsNames_148, argsValues_149);
                    localApi_110.sendToRemote(dataOut_146.toArray());
                    
                }
                
            };
            
        }
        
    };
    @Command(3) void changeParent(UUID uid);
    @Command(4) void changeAlias(UUID alias);
    @Command(5) void newChild(UUID uid);
    @Command(6) void sendMessages(Message[] msg);
    @Command(7) void sendServerDescriptor(ServerDescriptor serverDescriptor);
    @Command(8) void sendServerDescriptors(ServerDescriptor[] serverDescriptors);
    @Command(9) void sendCloud(UUID uid, Cloud cloud);
    @Command(10) void sendClouds(UUIDAndCloud[] clouds);
    @Command(11) void requestTelemetry();
    
}

=== Файл: ClientApiSafeLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class ClientApiSafeLocal<RT> implements ClientApiSafe {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected ClientApiSafeLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: ClientApiSafeRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ClientApiSafeRemote extends ClientApiSafe, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: ClientApiStream.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public class ClientApiStream implements io.aether.utils.ToString  {
    public static final FastMetaType<ClientApiStream> META = new FastMetaType<>()  {
        @Override public void serialize(FastFutureContext ctx, ClientApiStream obj, DataOut out)  {
            FastMeta.META_ARRAY_BYTE.serialize(ctx, obj.data, out);
            
        }
        @Override public ClientApiStream deserialize(FastFutureContext ctx, DataIn in)  {
            return new ClientApiStream(FastMeta.META_ARRAY_BYTE.deserialize(ctx, in));
            
        }
        
    };
    public final byte[] data;
    public ClientApiStream(byte[] data)  {
        this.data = data;
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("ClientApiStream(");
        sb.add("data[").add(this.data.length).add("]:").add(this.data);
        sb.add(')');
        
    }
    public void accept(FastFutureContext context,ServerApiByUid localApi)  {
        ServerApiByUid.META.makeLocal(context, new DataInOutStatic(this.data), localApi);
        
    }
    public void accept(ServerApiByUid localApi)  {
        accept(((FastFutureContextGetter)localApi).getFastFutureContext(),localApi);
        
    }
    public void accept(FastApiContextLocal<? extends ServerApiByUid> context)  {
        accept(context, context.localApi);
        
    }
    public ClientApiStream(FastFutureContext context,AConsumer<ServerApiByUidRemote> remote)  {
        var api= ServerApiByUid.META.makeRemote(context);
        remote.accept(api);
        this.data=context.remoteDataToArray();
        
    }
    public ClientApiStream(FastFutureContext context,io.aether.net.fastMeta.RemoteApiFuture<ServerApiByUidRemote> remote, AFuture sendFuture)  {
        remote.executeAll(context,sendFuture);
        this.data=context.remoteDataToArray();
        
    }
    public ClientApiStream(FastFutureContextGetter context,AConsumer<ServerApiByUidRemote> remote)  {
        this(context.getFastFutureContext(),remote);
        
    }
    
}

=== Файл: ClientApiUnsafe.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ClientApiUnsafe  {
    FastMetaApi<ClientApiUnsafe,ClientApiUnsafeRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_38, DataIn in_, ClientApiUnsafe localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_39 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_38,in_);
                        var futureRec_40 = serializeContextVar_38.getFuture(requestId_39);
                        if(futureRec_40 != null) futureRec_40.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_41 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_38,in_);
                        var futureRec_42 = serializeContextVar_38.getFuture(requestId_41);
                        if(futureRec_42 != null) futureRec_42.onError(in_);
                        break;
                        
                    }
                    case 3:  {
                        byte backId_44;
                        LoginClientStream data_45;
                        backId_44=in_.readByte();
                        data_45=LoginClientStream.META.deserialize(serializeContextVar_38,in_);
                        String[] argsNames_46 = new String[] {
                            "backId", "data"
                        };
                        Object[] argsValues_47 = new Object[] {
                            backId_44, data_45
                        };
                        serializeContextVar_38.invokeLocalMethodBefore("sendSafeApiDataMulti", argsNames_46, argsValues_47);
                        localApi.sendSafeApiDataMulti(backId_44,data_45);
                        serializeContextVar_38.invokeLocalMethodAfter("sendSafeApiDataMulti", null, argsNames_46, argsValues_47);
                        break;
                        
                    }
                    case 4:  {
                        LoginClientStream data_49;
                        data_49=LoginClientStream.META.deserialize(serializeContextVar_38,in_);
                        String[] argsNames_50 = new String[] {
                            "data"
                        };
                        Object[] argsValues_51 = new Object[] {
                            data_49
                        };
                        serializeContextVar_38.invokeLocalMethodBefore("sendSafeApiData", argsNames_50, argsValues_51);
                        localApi.sendSafeApiData(data_49);
                        serializeContextVar_38.invokeLocalMethodAfter("sendSafeApiData", null, argsNames_50, argsValues_51);
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public ClientApiUnsafeRemote makeRemote(FastFutureContext localApi_53) {
            return new ClientApiUnsafeRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_53.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_53;
                    
                }
                @Override public @Command(3) void sendSafeApiDataMulti(byte backId, LoginClientStream data) {
                    var dataOut_54 = new DataInOut();
                    dataOut_54.writeByte(3);
                    String[] argsNames_56 = new String[] {
                        "backId", "data"
                    };
                    Object[] argsValues_57 = new Object[] {
                        backId, data
                    };
                    localApi_53.invokeRemoteMethodAfter("sendSafeApiDataMulti", null, argsNames_56, argsValues_57);
                    dataOut_54.writeByte(backId);
                    LoginClientStream.META.serialize(localApi_53,data,dataOut_54);
                    localApi_53.sendToRemote(dataOut_54.toArray());
                    
                }
                @Override public @Command(4) void sendSafeApiData(LoginClientStream data) {
                    var dataOut_58 = new DataInOut();
                    dataOut_58.writeByte(4);
                    String[] argsNames_60 = new String[] {
                        "data"
                    };
                    Object[] argsValues_61 = new Object[] {
                        data
                    };
                    localApi_53.invokeRemoteMethodAfter("sendSafeApiData", null, argsNames_60, argsValues_61);
                    LoginClientStream.META.serialize(localApi_53,data,dataOut_58);
                    localApi_53.sendToRemote(dataOut_58.toArray());
                    
                }
                
            };
            
        }
        
    };
    @Command(3) void sendSafeApiDataMulti(byte backId, LoginClientStream data);
    @Command(4) void sendSafeApiData(LoginClientStream data);
    
}

=== Файл: ClientApiUnsafeLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class ClientApiUnsafeLocal<RT> implements ClientApiUnsafe {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected ClientApiUnsafeLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: ClientApiUnsafeRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ClientApiUnsafeRemote extends ClientApiUnsafe, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: ClientInteractionClientStream.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public class ClientInteractionClientStream implements io.aether.utils.ToString  {
    public static final FastMetaType<ClientInteractionClientStream> META = new FastMetaType<>()  {
        @Override public void serialize(FastFutureContext ctx, ClientInteractionClientStream obj, DataOut out)  {
            FastMeta.META_ARRAY_BYTE.serialize(ctx, obj.data, out);
            
        }
        @Override public ClientInteractionClientStream deserialize(FastFutureContext ctx, DataIn in)  {
            return new ClientInteractionClientStream(FastMeta.META_ARRAY_BYTE.deserialize(ctx, in));
            
        }
        
    };
    public final byte[] data;
    public ClientInteractionClientStream(byte[] data)  {
        this.data = data;
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("ClientInteractionClientStream(");
        sb.add("data[").add(this.data.length).add("]:").add(this.data);
        sb.add(')');
        
    }
    public void accept(FastFutureContext context,ServerApiByUidClient localApi)  {
        ServerApiByUidClient.META.makeLocal(context, new DataInOutStatic(this.data), localApi);
        
    }
    public void accept(ServerApiByUidClient localApi)  {
        accept(((FastFutureContextGetter)localApi).getFastFutureContext(),localApi);
        
    }
    public void accept(FastApiContextLocal<? extends ServerApiByUidClient> context)  {
        accept(context, context.localApi);
        
    }
    public ClientInteractionClientStream(FastFutureContext context,AConsumer<ServerApiByUidClientRemote> remote)  {
        var api= ServerApiByUidClient.META.makeRemote(context);
        remote.accept(api);
        this.data=context.remoteDataToArray();
        
    }
    public ClientInteractionClientStream(FastFutureContext context,io.aether.net.fastMeta.RemoteApiFuture<ServerApiByUidClientRemote> remote, AFuture sendFuture)  {
        remote.executeAll(context,sendFuture);
        this.data=context.remoteDataToArray();
        
    }
    public ClientInteractionClientStream(FastFutureContextGetter context,AConsumer<ServerApiByUidClientRemote> remote)  {
        this(context.getFastFutureContext(),remote);
        
    }
    
}

=== Файл: ClientServerRegApiMeta.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public final class ClientServerRegApiMeta  {
    public final static FastMetaType<ServerDescriptor[]> META_ARRAY_ServerDescriptor=new FastMetaType<>() {
        @Override public void serialize(FastFutureContext serializeContext, ServerDescriptor[] obj, DataOut out) {
            SerializerPackNumber.INSTANCE.put(out, obj.length);
            for(var el_130 : obj) {
                ServerDescriptor.META.serialize(serializeContext, el_130, out);
                
            }
            
        }
        @Override public ServerDescriptor[] deserialize(FastFutureContext serializeContext, DataIn in) {
            var len_131 = DeserializerPackNumber.INSTANCE.put(in).intValue();
            var ar = new ServerDescriptor[len_131];
            for(var i_132=0; i_132<len_131; i_132++) {
                ar[i_132] = ServerDescriptor.META.deserialize(serializeContext, in);
                
            }
            return ar;
            
        }
        
    };
    
}

=== Файл: FinishResult.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public class FinishResult implements io.aether.utils.ToString  {
    public static final FastMetaType<FinishResult> META_BODY = new FastMetaType<>() {
        @Override public void serialize(FastFutureContext serializeContextVar_37, FinishResult obj_38, DataOut out_39) {
            FastMeta.META_UUID.serialize(serializeContextVar_37,obj_38.alias,out_39);
            FastMeta.META_UUID.serialize(serializeContextVar_37,obj_38.uid,out_39);
            Cloud.META.serialize(serializeContextVar_37,obj_38.cloud,out_39);
            
        }
        @Override public FinishResult deserialize(FastFutureContext serializeContextVar_37, DataIn in_40) {
            UUID alias_41;
            UUID uid_42;
            Cloud cloud_43;
            alias_41=FastMeta.META_UUID.deserialize(serializeContextVar_37,in_40);
            uid_42=FastMeta.META_UUID.deserialize(serializeContextVar_37,in_40);
            cloud_43=Cloud.META.deserialize(serializeContextVar_37,in_40);
            return new FinishResult(alias_41,uid_42,cloud_43);
            
        }
        
    };
    public static final FastMetaType<FinishResult> META = new FastMetaType<>() {
        @Override public void serialize(FastFutureContext serializeContextVar_44, FinishResult obj_45, DataOut out_46) {
            FinishResult.META_BODY.serialize(serializeContextVar_44, obj_45, out_46);
            
        }
        @Override public FinishResult deserialize(FastFutureContext serializeContextVar_44, DataIn in_47) {
            return FinishResult.META_BODY.deserialize(serializeContextVar_44, in_47);
            
        }
        
    };
    protected final UUID alias;
    protected final UUID uid;
    protected final Cloud cloud;
    public FinishResult(UUID alias, UUID uid, Cloud cloud)  {
        if (cloud == null)  {
            throw new java.lang.NullPointerException("Field 'cloud' cannot be null.");
            
        }
        this.alias = alias;
        this.uid = uid;
        this.cloud = cloud;
        
    }
    public UUID getAlias()  {
        return this.alias;
        
    }
    public UUID getUid()  {
        return this.uid;
        
    }
    public Cloud getCloud()  {
        return this.cloud;
        
    }
    @Override public boolean equals(Object o)  {
        if (this == o) return true;
        if (o == null || !(o instanceof FinishResult)) return false;
        FinishResult that = (FinishResult) o;
        return java.util.Objects.equals(this.alias, that.alias) && java.util.Objects.equals(this.uid, that.uid) && java.util.Objects.equals(this.cloud, that.cloud);
        
    }
    @Override public int hashCode()  {
        return java.util.Objects.hash(this.alias, this.uid, this.cloud);
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("FinishResult(");
        sb.add("alias:");
        sb.add(this.alias);
        sb.add(", ");
        sb.add("uid:");
        sb.add(this.uid);
        sb.add(", ");
        sb.add("cloud:");
        sb.add(this.cloud);
        sb.add(')');
        
    }
    
}

=== Файл: GlobalApiStream.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public class GlobalApiStream implements io.aether.utils.ToString  {
    public static final FastMetaType<GlobalApiStream> META = new FastMetaType<>()  {
        @Override public void serialize(FastFutureContext ctx, GlobalApiStream obj, DataOut out)  {
            FastMeta.META_ARRAY_BYTE.serialize(ctx, obj.data, out);
            
        }
        @Override public GlobalApiStream deserialize(FastFutureContext ctx, DataIn in)  {
            return new GlobalApiStream(FastMeta.META_ARRAY_BYTE.deserialize(ctx, in));
            
        }
        
    };
    public final byte[] data;
    public GlobalApiStream(byte[] data)  {
        this.data = data;
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("GlobalApiStream(");
        sb.add("data[").add(this.data.length).add("]:").add(this.data);
        sb.add(')');
        
    }
    public void accept(FastFutureContext context, BytesConverter provider, GlobalRegServerApi localApi)  {
        byte[] decryptedData = provider.apply(this.data);
        GlobalRegServerApi.META.makeLocal(context, new DataInOutStatic(decryptedData), localApi);
        
    }
    public void accept(FastApiContextLocal<? extends GlobalRegServerApi> context, BytesConverter provider)  {
        accept(context, provider, context.localApi);
        
    }
    public void accept(BytesConverter provider, GlobalRegServerApi localApi)  {
        accept(((FastFutureContextGetter)localApi).getFastFutureContext(),provider,localApi);
        
    }
    public GlobalApiStream(FastFutureContext context,BytesConverter provider, io.aether.net.fastMeta.RemoteApiFuture<GlobalRegServerApiRemote> remote, AFuture sendFuture)  {
        remote.executeAll(context, sendFuture);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public GlobalApiStream(FastFutureContext context,BytesConverter provider, AConsumer<GlobalRegServerApiRemote> remote)  {
        var api= GlobalRegServerApi.META.makeRemote(context);
        remote.accept(api);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public GlobalApiStream(BytesConverter provider, byte[] remoteData)  {
        this.data=provider.apply(remoteData);
        
    }
    public GlobalApiStream(FastFutureContextGetter context,BytesConverter provider, AConsumer<GlobalRegServerApiRemote> remote)  {
        this(context.getFastFutureContext(),provider, remote);
        
    }
    
}

=== Файл: GlobalRegClientApi.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface GlobalRegClientApi  {
    GlobalRegClientApi EMPTY=new GlobalRegClientApi() {
        
    };
    FastMetaApi<GlobalRegClientApi,GlobalRegClientApiRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_7, DataIn in_, GlobalRegClientApi localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_8 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_7,in_);
                        var futureRec_9 = serializeContextVar_7.getFuture(requestId_8);
                        if(futureRec_9 != null) futureRec_9.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_10 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_7,in_);
                        var futureRec_11 = serializeContextVar_7.getFuture(requestId_10);
                        if(futureRec_11 != null) futureRec_11.onError(in_);
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public GlobalRegClientApiRemote makeRemote(FastFutureContext localApi_13) {
            return new GlobalRegClientApiRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_13.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_13;
                    
                }
                
            };
            
        }
        
    };
    
}

=== Файл: GlobalRegClientApiLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class GlobalRegClientApiLocal<RT> implements GlobalRegClientApi {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected GlobalRegClientApiLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: GlobalRegClientApiRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface GlobalRegClientApiRemote extends GlobalRegClientApi, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: GlobalRegClientApiStream.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public class GlobalRegClientApiStream implements io.aether.utils.ToString  {
    public static final FastMetaType<GlobalRegClientApiStream> META = new FastMetaType<>()  {
        @Override public void serialize(FastFutureContext ctx, GlobalRegClientApiStream obj, DataOut out)  {
            FastMeta.META_ARRAY_BYTE.serialize(ctx, obj.data, out);
            
        }
        @Override public GlobalRegClientApiStream deserialize(FastFutureContext ctx, DataIn in)  {
            return new GlobalRegClientApiStream(FastMeta.META_ARRAY_BYTE.deserialize(ctx, in));
            
        }
        
    };
    public final byte[] data;
    public GlobalRegClientApiStream(byte[] data)  {
        this.data = data;
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("GlobalRegClientApiStream(");
        sb.add("data[").add(this.data.length).add("]:").add(this.data);
        sb.add(')');
        
    }
    public void accept(FastFutureContext context, BytesConverter provider, GlobalRegClientApi localApi)  {
        byte[] decryptedData = provider.apply(this.data);
        GlobalRegClientApi.META.makeLocal(context, new DataInOutStatic(decryptedData), localApi);
        
    }
    public void accept(FastApiContextLocal<? extends GlobalRegClientApi> context, BytesConverter provider)  {
        accept(context, provider, context.localApi);
        
    }
    public void accept(BytesConverter provider, GlobalRegClientApi localApi)  {
        accept(((FastFutureContextGetter)localApi).getFastFutureContext(),provider,localApi);
        
    }
    public GlobalRegClientApiStream(FastFutureContext context,BytesConverter provider, io.aether.net.fastMeta.RemoteApiFuture<GlobalRegClientApiRemote> remote, AFuture sendFuture)  {
        remote.executeAll(context, sendFuture);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public GlobalRegClientApiStream(FastFutureContext context,BytesConverter provider, AConsumer<GlobalRegClientApiRemote> remote)  {
        var api= GlobalRegClientApi.META.makeRemote(context);
        remote.accept(api);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public GlobalRegClientApiStream(BytesConverter provider, byte[] remoteData)  {
        this.data=provider.apply(remoteData);
        
    }
    public GlobalRegClientApiStream(FastFutureContextGetter context,BytesConverter provider, AConsumer<GlobalRegClientApiRemote> remote)  {
        this(context.getFastFutureContext(),provider, remote);
        
    }
    
}

=== Файл: GlobalRegServerApi.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface GlobalRegServerApi  {
    FastMetaApi<GlobalRegServerApi,GlobalRegServerApiRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_48, DataIn in_, GlobalRegServerApi localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_49 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_48,in_);
                        var futureRec_50 = serializeContextVar_48.getFuture(requestId_49);
                        if(futureRec_50 != null) futureRec_50.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_51 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_48,in_);
                        var futureRec_52 = serializeContextVar_48.getFuture(requestId_51);
                        if(futureRec_52 != null) futureRec_52.onError(in_);
                        break;
                        
                    }
                    case 3:  {
                        Key key_54;
                        key_54=Key.META.deserialize(serializeContextVar_48,in_);
                        String[] argsNames_55 = new String[] {
                            "key"
                        };
                        Object[] argsValues_56 = new Object[] {
                            key_54
                        };
                        serializeContextVar_48.invokeLocalMethodBefore("setMasterKey", argsNames_55, argsValues_56);
                        localApi.setMasterKey(key_54);
                        serializeContextVar_48.invokeLocalMethodAfter("setMasterKey", null, argsNames_55, argsValues_56);
                        break;
                        
                    }
                    case 4:  {
                        int requestId_57 = in_.readInt();
                        String[] argsNames_58 = new String[] {
                            
                        };
                        Object[] argsValues_59 = new Object[] {
                            
                        };
                        serializeContextVar_48.invokeLocalMethodBefore("finish", argsNames_58, argsValues_59);
                        serializeContextVar_48.regLocalFuture();
                        var result_60 = localApi.finish();
                        serializeContextVar_48.invokeLocalMethodAfter("finish", result_60, argsNames_58, argsValues_59);
                        result_60.to((v_62)-> {
                            var data_61 = new DataInOut();
                            FinishResult.META.serialize(serializeContextVar_48,v_62,data_61);
                            serializeContextVar_48.sendResultToRemote(requestId_57,data_61.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public GlobalRegServerApiRemote makeRemote(FastFutureContext localApi_64) {
            return new GlobalRegServerApiRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_64.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_64;
                    
                }
                @Override public @Command(3) void setMasterKey(Key key) {
                    var dataOut_65 = new DataInOut();
                    dataOut_65.writeByte(3);
                    String[] argsNames_67 = new String[] {
                        "key"
                    };
                    Object[] argsValues_68 = new Object[] {
                        key
                    };
                    localApi_64.invokeRemoteMethodAfter("setMasterKey", null, argsNames_67, argsValues_68);
                    Key.META.serialize(localApi_64,key,dataOut_65);
                    localApi_64.sendToRemote(dataOut_65.toArray());
                    
                }
                @Override public @Command(4) ARFuture<FinishResult> finish() {
                    var dataOut_69 = new DataInOut();
                    dataOut_69.writeByte(4);
                    String[] argsNames_71 = new String[] {
                        
                    };
                    Object[] argsValues_72 = new Object[] {
                        
                    };
                    var result_70 = ARFuture.<FinishResult>of();
                    localApi_64.invokeRemoteMethodAfter("finish", result_70, argsNames_71, argsValues_72);
                    var requestId_73 = localApi_64.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_70.done(FinishResult.META.deserialize(localApi_64,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_70.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_69.writeInt(requestId_73);
                    localApi_64.sendToRemote(dataOut_69.toArray());
                    return result_70;
                    
                }
                
            };
            
        }
        
    };
    @Command(3) void setMasterKey(Key key);
    @Command(4) ARFuture<FinishResult> finish();
    
}

=== Файл: GlobalRegServerApiLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class GlobalRegServerApiLocal<RT> implements GlobalRegServerApi {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected GlobalRegServerApiLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: GlobalRegServerApiRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface GlobalRegServerApiRemote extends GlobalRegServerApi, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: LoginApi.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface LoginApi  {
    FastMetaApi<LoginApi,LoginApiRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_338, DataIn in_, LoginApi localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_339 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_338,in_);
                        var futureRec_340 = serializeContextVar_338.getFuture(requestId_339);
                        if(futureRec_340 != null) futureRec_340.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_341 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_338,in_);
                        var futureRec_342 = serializeContextVar_338.getFuture(requestId_341);
                        if(futureRec_342 != null) futureRec_342.onError(in_);
                        break;
                        
                    }
                    case 3:  {
                        int requestId_343 = in_.readInt();
                        String[] argsNames_344 = new String[] {
                            
                        };
                        Object[] argsValues_345 = new Object[] {
                            
                        };
                        serializeContextVar_338.invokeLocalMethodBefore("getTimeUTC", argsNames_344, argsValues_345);
                        serializeContextVar_338.regLocalFuture();
                        var result_346 = localApi.getTimeUTC();
                        serializeContextVar_338.invokeLocalMethodAfter("getTimeUTC", result_346, argsNames_344, argsValues_345);
                        result_346.to((v_348)-> {
                            var data_347 = new DataInOut();
                            data_347.writeLong(v_348);
                            serializeContextVar_338.sendResultToRemote(requestId_343,data_347.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 4:  {
                        UUID uid_350;
                        LoginStream data_351;
                        uid_350=FastMeta.META_UUID.deserialize(serializeContextVar_338,in_);
                        data_351=LoginStream.META.deserialize(serializeContextVar_338,in_);
                        String[] argsNames_352 = new String[] {
                            "uid", "data"
                        };
                        Object[] argsValues_353 = new Object[] {
                            uid_350, data_351
                        };
                        serializeContextVar_338.invokeLocalMethodBefore("loginByUID", argsNames_352, argsValues_353);
                        localApi.loginByUID(uid_350,data_351);
                        serializeContextVar_338.invokeLocalMethodAfter("loginByUID", null, argsNames_352, argsValues_353);
                        break;
                        
                    }
                    case 5:  {
                        UUID alias_355;
                        LoginStream data_356;
                        alias_355=FastMeta.META_UUID.deserialize(serializeContextVar_338,in_);
                        data_356=LoginStream.META.deserialize(serializeContextVar_338,in_);
                        String[] argsNames_357 = new String[] {
                            "alias", "data"
                        };
                        Object[] argsValues_358 = new Object[] {
                            alias_355, data_356
                        };
                        serializeContextVar_338.invokeLocalMethodBefore("loginByAlias", argsNames_357, argsValues_358);
                        localApi.loginByAlias(alias_355,data_356);
                        serializeContextVar_338.invokeLocalMethodAfter("loginByAlias", null, argsNames_357, argsValues_358);
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public LoginApiRemote makeRemote(FastFutureContext localApi_360) {
            return new LoginApiRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_360.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_360;
                    
                }
                @Override public @Command(3) ARFuture<Long> getTimeUTC() {
                    var dataOut_361 = new DataInOut();
                    dataOut_361.writeByte(3);
                    String[] argsNames_363 = new String[] {
                        
                    };
                    Object[] argsValues_364 = new Object[] {
                        
                    };
                    var result_362 = ARFuture.<Long>of();
                    localApi_360.invokeRemoteMethodAfter("getTimeUTC", result_362, argsNames_363, argsValues_364);
                    var requestId_365 = localApi_360.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_362.done(FastMeta.META_LONG.deserialize(localApi_360,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_362.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_361.writeInt(requestId_365);
                    localApi_360.sendToRemote(dataOut_361.toArray());
                    return result_362;
                    
                }
                @Override public @Command(4) void loginByUID(UUID uid, LoginStream data) {
                    var dataOut_366 = new DataInOut();
                    dataOut_366.writeByte(4);
                    String[] argsNames_368 = new String[] {
                        "uid", "data"
                    };
                    Object[] argsValues_369 = new Object[] {
                        uid, data
                    };
                    localApi_360.invokeRemoteMethodAfter("loginByUID", null, argsNames_368, argsValues_369);
                    FastMeta.META_UUID.serialize(localApi_360,uid,dataOut_366);
                    LoginStream.META.serialize(localApi_360,data,dataOut_366);
                    localApi_360.sendToRemote(dataOut_366.toArray());
                    
                }
                @Override public @Command(5) void loginByAlias(UUID alias, LoginStream data) {
                    var dataOut_370 = new DataInOut();
                    dataOut_370.writeByte(5);
                    String[] argsNames_372 = new String[] {
                        "alias", "data"
                    };
                    Object[] argsValues_373 = new Object[] {
                        alias, data
                    };
                    localApi_360.invokeRemoteMethodAfter("loginByAlias", null, argsNames_372, argsValues_373);
                    FastMeta.META_UUID.serialize(localApi_360,alias,dataOut_370);
                    LoginStream.META.serialize(localApi_360,data,dataOut_370);
                    localApi_360.sendToRemote(dataOut_370.toArray());
                    
                }
                
            };
            
        }
        
    };
    @Command(3) ARFuture<Long> getTimeUTC();
    @Command(4) void loginByUID(UUID uid, LoginStream data);
    @Command(5) void loginByAlias(UUID alias, LoginStream data);
    
}

=== Файл: LoginApiLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class LoginApiLocal<RT> implements LoginApi {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected LoginApiLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: LoginApiRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface LoginApiRemote extends LoginApi, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: LoginClientStream.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public class LoginClientStream implements io.aether.utils.ToString  {
    public static final FastMetaType<LoginClientStream> META = new FastMetaType<>()  {
        @Override public void serialize(FastFutureContext ctx, LoginClientStream obj, DataOut out)  {
            FastMeta.META_ARRAY_BYTE.serialize(ctx, obj.data, out);
            
        }
        @Override public LoginClientStream deserialize(FastFutureContext ctx, DataIn in)  {
            return new LoginClientStream(FastMeta.META_ARRAY_BYTE.deserialize(ctx, in));
            
        }
        
    };
    public final byte[] data;
    public LoginClientStream(byte[] data)  {
        this.data = data;
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("LoginClientStream(");
        sb.add("data[").add(this.data.length).add("]:").add(this.data);
        sb.add(')');
        
    }
    public void accept(FastFutureContext context, BytesConverter provider, ClientApiSafe localApi)  {
        byte[] decryptedData = provider.apply(this.data);
        ClientApiSafe.META.makeLocal(context, new DataInOutStatic(decryptedData), localApi);
        
    }
    public void accept(FastApiContextLocal<? extends ClientApiSafe> context, BytesConverter provider)  {
        accept(context, provider, context.localApi);
        
    }
    public void accept(BytesConverter provider, ClientApiSafe localApi)  {
        accept(((FastFutureContextGetter)localApi).getFastFutureContext(),provider,localApi);
        
    }
    public LoginClientStream(FastFutureContext context,BytesConverter provider, io.aether.net.fastMeta.RemoteApiFuture<ClientApiSafeRemote> remote, AFuture sendFuture)  {
        remote.executeAll(context, sendFuture);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public LoginClientStream(FastFutureContext context,BytesConverter provider, AConsumer<ClientApiSafeRemote> remote)  {
        var api= ClientApiSafe.META.makeRemote(context);
        remote.accept(api);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public LoginClientStream(BytesConverter provider, byte[] remoteData)  {
        this.data=provider.apply(remoteData);
        
    }
    public LoginClientStream(FastFutureContextGetter context,BytesConverter provider, AConsumer<ClientApiSafeRemote> remote)  {
        this(context.getFastFutureContext(),provider, remote);
        
    }
    
}

=== Файл: LoginStream.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public class LoginStream implements io.aether.utils.ToString  {
    public static final FastMetaType<LoginStream> META = new FastMetaType<>()  {
        @Override public void serialize(FastFutureContext ctx, LoginStream obj, DataOut out)  {
            FastMeta.META_ARRAY_BYTE.serialize(ctx, obj.data, out);
            
        }
        @Override public LoginStream deserialize(FastFutureContext ctx, DataIn in)  {
            return new LoginStream(FastMeta.META_ARRAY_BYTE.deserialize(ctx, in));
            
        }
        
    };
    public final byte[] data;
    public LoginStream(byte[] data)  {
        this.data = data;
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("LoginStream(");
        sb.add("data[").add(this.data.length).add("]:").add(this.data);
        sb.add(')');
        
    }
    public void accept(FastFutureContext context, BytesConverter provider, AuthorizedApi localApi)  {
        byte[] decryptedData = provider.apply(this.data);
        AuthorizedApi.META.makeLocal(context, new DataInOutStatic(decryptedData), localApi);
        
    }
    public void accept(FastApiContextLocal<? extends AuthorizedApi> context, BytesConverter provider)  {
        accept(context, provider, context.localApi);
        
    }
    public void accept(BytesConverter provider, AuthorizedApi localApi)  {
        accept(((FastFutureContextGetter)localApi).getFastFutureContext(),provider,localApi);
        
    }
    public LoginStream(FastFutureContext context,BytesConverter provider, io.aether.net.fastMeta.RemoteApiFuture<AuthorizedApiRemote> remote, AFuture sendFuture)  {
        remote.executeAll(context, sendFuture);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public LoginStream(FastFutureContext context,BytesConverter provider, AConsumer<AuthorizedApiRemote> remote)  {
        var api= AuthorizedApi.META.makeRemote(context);
        remote.accept(api);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public LoginStream(BytesConverter provider, byte[] remoteData)  {
        this.data=provider.apply(remoteData);
        
    }
    public LoginStream(FastFutureContextGetter context,BytesConverter provider, AConsumer<AuthorizedApiRemote> remote)  {
        this(context.getFastFutureContext(),provider, remote);
        
    }
    
}

=== Файл: Message.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public class Message implements io.aether.utils.ToString  {
    public static final FastMetaType<Message> META_BODY = new FastMetaType<>() {
        @Override public void serialize(FastFutureContext serializeContextVar_27, Message obj_28, DataOut out_29) {
            FastMeta.META_UUID.serialize(serializeContextVar_27,obj_28.uid,out_29);
            SerializerPackNumber.INSTANCE.put(out_29,obj_28.data.length);
            out_29.write(obj_28.data);
            
        }
        @Override public Message deserialize(FastFutureContext serializeContextVar_27, DataIn in_30) {
            UUID uid_31;
            byte[] data_32;
            uid_31=FastMeta.META_UUID.deserialize(serializeContextVar_27,in_30);
            var arraySize_33 = DeserializerPackNumber.INSTANCE.put(in_30).intValue();
            data_32=new byte[arraySize_33];
            in_30.read(data_32);
            return new Message(uid_31,data_32);
            
        }
        
    };
    public static final FastMetaType<Message> META = new FastMetaType<>() {
        @Override public void serialize(FastFutureContext serializeContextVar_34, Message obj_35, DataOut out_36) {
            Message.META_BODY.serialize(serializeContextVar_34, obj_35, out_36);
            
        }
        @Override public Message deserialize(FastFutureContext serializeContextVar_34, DataIn in_37) {
            return Message.META_BODY.deserialize(serializeContextVar_34, in_37);
            
        }
        
    };
    protected final UUID uid;
    protected final byte[] data;
    public Message(UUID uid, byte[] data)  {
        if (data == null)  {
            throw new java.lang.NullPointerException("Field 'data' cannot be null.");
            
        }
        this.uid = uid;
        this.data = data;
        
    }
    public UUID getUid()  {
        return this.uid;
        
    }
    public byte[] getData()  {
        return this.data;
        
    }
    public boolean dataContains(byte el)  {
        return ByteSet.of(this.data).contains(el);
        
    }
    @Override public boolean equals(Object o)  {
        if (this == o) return true;
        if (o == null || !(o instanceof Message)) return false;
        Message that = (Message) o;
        return java.util.Objects.equals(this.uid, that.uid) && java.util.Arrays.equals(this.data, that.data);
        
    }
    @Override public int hashCode()  {
        return java.util.Objects.hash(this.uid, java.util.Arrays.hashCode(this.data));
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("Message(");
        sb.add("uid:");
        sb.add(this.uid);
        sb.add(", ");
        sb.add("data:");
        sb.add(this.data);
        sb.add(')');
        
    }
    
}

=== Файл: RegistrationRootApi.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface RegistrationRootApi  {
    FastMetaApi<RegistrationRootApi,RegistrationRootApiRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_133, DataIn in_, RegistrationRootApi localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_134 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_133,in_);
                        var futureRec_135 = serializeContextVar_133.getFuture(requestId_134);
                        if(futureRec_135 != null) futureRec_135.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_136 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_133,in_);
                        var futureRec_137 = serializeContextVar_133.getFuture(requestId_136);
                        if(futureRec_137 != null) futureRec_137.onError(in_);
                        break;
                        
                    }
                    case 3:  {
                        int requestId_138 = in_.readInt();
                        CryptoLib cryptoLib_139;
                        cryptoLib_139=CryptoLib.META.deserialize(serializeContextVar_133,in_);
                        String[] argsNames_140 = new String[] {
                            "cryptoLib"
                        };
                        Object[] argsValues_141 = new Object[] {
                            cryptoLib_139
                        };
                        serializeContextVar_133.invokeLocalMethodBefore("getAsymmetricPublicKey", argsNames_140, argsValues_141);
                        serializeContextVar_133.regLocalFuture();
                        var result_142 = localApi.getAsymmetricPublicKey(cryptoLib_139);
                        serializeContextVar_133.invokeLocalMethodAfter("getAsymmetricPublicKey", result_142, argsNames_140, argsValues_141);
                        result_142.to((v_144)-> {
                            var data_143 = new DataInOut();
                            SignedKey.META.serialize(serializeContextVar_133,v_144,data_143);
                            serializeContextVar_133.sendResultToRemote(requestId_138,data_143.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 4:  {
                        CryptoLib cryptoLib_146;
                        ServerRegistrationApiStream stream_147;
                        cryptoLib_146=CryptoLib.META.deserialize(serializeContextVar_133,in_);
                        stream_147=ServerRegistrationApiStream.META.deserialize(serializeContextVar_133,in_);
                        String[] argsNames_148 = new String[] {
                            "cryptoLib", "stream"
                        };
                        Object[] argsValues_149 = new Object[] {
                            cryptoLib_146, stream_147
                        };
                        serializeContextVar_133.invokeLocalMethodBefore("enter", argsNames_148, argsValues_149);
                        localApi.enter(cryptoLib_146,stream_147);
                        serializeContextVar_133.invokeLocalMethodAfter("enter", null, argsNames_148, argsValues_149);
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public RegistrationRootApiRemote makeRemote(FastFutureContext localApi_151) {
            return new RegistrationRootApiRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_151.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_151;
                    
                }
                @Override public @Command(3) ARFuture<SignedKey> getAsymmetricPublicKey(CryptoLib cryptoLib) {
                    var dataOut_152 = new DataInOut();
                    dataOut_152.writeByte(3);
                    String[] argsNames_154 = new String[] {
                        "cryptoLib"
                    };
                    Object[] argsValues_155 = new Object[] {
                        cryptoLib
                    };
                    var result_153 = ARFuture.<SignedKey>of();
                    localApi_151.invokeRemoteMethodAfter("getAsymmetricPublicKey", result_153, argsNames_154, argsValues_155);
                    var requestId_156 = localApi_151.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_153.done(SignedKey.META.deserialize(localApi_151,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_153.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_152.writeInt(requestId_156);
                    CryptoLib.META.serialize(localApi_151,cryptoLib,dataOut_152);
                    localApi_151.sendToRemote(dataOut_152.toArray());
                    return result_153;
                    
                }
                @Override public @Command(4) void enter(CryptoLib cryptoLib, ServerRegistrationApiStream stream) {
                    var dataOut_157 = new DataInOut();
                    dataOut_157.writeByte(4);
                    String[] argsNames_159 = new String[] {
                        "cryptoLib", "stream"
                    };
                    Object[] argsValues_160 = new Object[] {
                        cryptoLib, stream
                    };
                    localApi_151.invokeRemoteMethodAfter("enter", null, argsNames_159, argsValues_160);
                    CryptoLib.META.serialize(localApi_151,cryptoLib,dataOut_157);
                    ServerRegistrationApiStream.META.serialize(localApi_151,stream,dataOut_157);
                    localApi_151.sendToRemote(dataOut_157.toArray());
                    
                }
                
            };
            
        }
        
    };
    @Command(3) ARFuture<SignedKey> getAsymmetricPublicKey(CryptoLib cryptoLib);
    @Command(4) void enter(CryptoLib cryptoLib, ServerRegistrationApiStream stream);
    
}

=== Файл: RegistrationRootApiLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class RegistrationRootApiLocal<RT> implements RegistrationRootApi {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected RegistrationRootApiLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: RegistrationRootApiRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface RegistrationRootApiRemote extends RegistrationRootApi, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: ServerApiByUidClient.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ServerApiByUidClient  {
    ServerApiByUidClient EMPTY=new ServerApiByUidClient() {
        
    };
    FastMetaApi<ServerApiByUidClient,ServerApiByUidClientRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_374, DataIn in_, ServerApiByUidClient localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_375 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_374,in_);
                        var futureRec_376 = serializeContextVar_374.getFuture(requestId_375);
                        if(futureRec_376 != null) futureRec_376.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_377 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_374,in_);
                        var futureRec_378 = serializeContextVar_374.getFuture(requestId_377);
                        if(futureRec_378 != null) futureRec_378.onError(in_);
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public ServerApiByUidClientRemote makeRemote(FastFutureContext localApi_380) {
            return new ServerApiByUidClientRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_380.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_380;
                    
                }
                
            };
            
        }
        
    };
    
}

=== Файл: ServerApiByUidClientLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class ServerApiByUidClientLocal<RT> implements ServerApiByUidClient {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected ServerApiByUidClientLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: ServerApiByUidClientRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ServerApiByUidClientRemote extends ServerApiByUidClient, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: ServerApiByUid.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ServerApiByUid  {
    FastMetaApi<ServerApiByUid,ServerApiByUidRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_381, DataIn in_, ServerApiByUid localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_382 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_381,in_);
                        var futureRec_383 = serializeContextVar_381.getFuture(requestId_382);
                        if(futureRec_383 != null) futureRec_383.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_384 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_381,in_);
                        var futureRec_385 = serializeContextVar_381.getFuture(requestId_384);
                        if(futureRec_385 != null) futureRec_385.onError(in_);
                        break;
                        
                    }
                    case 3:  {
                        int requestId_386 = in_.readInt();
                        String[] argsNames_387 = new String[] {
                            
                        };
                        Object[] argsValues_388 = new Object[] {
                            
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("getBalance", argsNames_387, argsValues_388);
                        serializeContextVar_381.regLocalFuture();
                        var result_389 = localApi.getBalance();
                        serializeContextVar_381.invokeLocalMethodAfter("getBalance", result_389, argsNames_387, argsValues_388);
                        result_389.to((v_391)-> {
                            var data_390 = new DataInOut();
                            data_390.writeLong(v_391);
                            serializeContextVar_381.sendResultToRemote(requestId_386,data_390.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 4:  {
                        int requestId_392 = in_.readInt();
                        UUID uid_393;
                        uid_393=FastMeta.META_UUID.deserialize(serializeContextVar_381,in_);
                        String[] argsNames_394 = new String[] {
                            "uid"
                        };
                        Object[] argsValues_395 = new Object[] {
                            uid_393
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("setParent", argsNames_394, argsValues_395);
                        serializeContextVar_381.regLocalFuture();
                        var result_396 = localApi.setParent(uid_393);
                        serializeContextVar_381.invokeLocalMethodAfter("setParent", result_396, argsNames_394, argsValues_395);
                        result_396.to(()-> {
                            var data_397 = new DataInOut();
                            serializeContextVar_381.sendResultToRemote(requestId_392);
                            
                        }
                        );
                        break;
                        
                    }
                    case 5:  {
                        int requestId_398 = in_.readInt();
                        String[] argsNames_399 = new String[] {
                            
                        };
                        Object[] argsValues_400 = new Object[] {
                            
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("block", argsNames_399, argsValues_400);
                        serializeContextVar_381.regLocalFuture();
                        var result_401 = localApi.block();
                        serializeContextVar_381.invokeLocalMethodAfter("block", result_401, argsNames_399, argsValues_400);
                        result_401.to(()-> {
                            var data_402 = new DataInOut();
                            serializeContextVar_381.sendResultToRemote(requestId_398);
                            
                        }
                        );
                        break;
                        
                    }
                    case 6:  {
                        int requestId_403 = in_.readInt();
                        String[] argsNames_404 = new String[] {
                            
                        };
                        Object[] argsValues_405 = new Object[] {
                            
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("getPosition", argsNames_404, argsValues_405);
                        serializeContextVar_381.regLocalFuture();
                        var result_406 = localApi.getPosition();
                        serializeContextVar_381.invokeLocalMethodAfter("getPosition", result_406, argsNames_404, argsValues_405);
                        result_406.to((v_408)-> {
                            var data_407 = new DataInOut();
                            Cloud.META.serialize(serializeContextVar_381,v_408,data_407);
                            serializeContextVar_381.sendResultToRemote(requestId_403,data_407.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 7:  {
                        int requestId_409 = in_.readInt();
                        String[] argsNames_410 = new String[] {
                            
                        };
                        Object[] argsValues_411 = new Object[] {
                            
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("getParent", argsNames_410, argsValues_411);
                        serializeContextVar_381.regLocalFuture();
                        var result_412 = localApi.getParent();
                        serializeContextVar_381.invokeLocalMethodAfter("getParent", result_412, argsNames_410, argsValues_411);
                        result_412.to((v_414)-> {
                            var data_413 = new DataInOut();
                            FastMeta.META_UUID.serialize(serializeContextVar_381,v_414,data_413);
                            serializeContextVar_381.sendResultToRemote(requestId_409,data_413.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 8:  {
                        int requestId_415 = in_.readInt();
                        String[] argsNames_416 = new String[] {
                            
                        };
                        Object[] argsValues_417 = new Object[] {
                            
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("getBeneficiary", argsNames_416, argsValues_417);
                        serializeContextVar_381.regLocalFuture();
                        var result_418 = localApi.getBeneficiary();
                        serializeContextVar_381.invokeLocalMethodAfter("getBeneficiary", result_418, argsNames_416, argsValues_417);
                        result_418.to((v_420)-> {
                            var data_419 = new DataInOut();
                            FastMeta.META_UUID.serialize(serializeContextVar_381,v_420,data_419);
                            serializeContextVar_381.sendResultToRemote(requestId_415,data_419.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 9:  {
                        int requestId_421 = in_.readInt();
                        UUID uid_422;
                        uid_422=FastMeta.META_UUID.deserialize(serializeContextVar_381,in_);
                        String[] argsNames_423 = new String[] {
                            "uid"
                        };
                        Object[] argsValues_424 = new Object[] {
                            uid_422
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("setBeneficiary", argsNames_423, argsValues_424);
                        serializeContextVar_381.regLocalFuture();
                        var result_425 = localApi.setBeneficiary(uid_422);
                        serializeContextVar_381.invokeLocalMethodAfter("setBeneficiary", result_425, argsNames_423, argsValues_424);
                        result_425.to(()-> {
                            var data_426 = new DataInOut();
                            serializeContextVar_381.sendResultToRemote(requestId_421);
                            
                        }
                        );
                        break;
                        
                    }
                    case 10:  {
                        int requestId_427 = in_.readInt();
                        String[] argsNames_428 = new String[] {
                            
                        };
                        Object[] argsValues_429 = new Object[] {
                            
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("getBlockTime", argsNames_428, argsValues_429);
                        serializeContextVar_381.regLocalFuture();
                        var result_430 = localApi.getBlockTime();
                        serializeContextVar_381.invokeLocalMethodAfter("getBlockTime", result_430, argsNames_428, argsValues_429);
                        result_430.to((v_432)-> {
                            var data_431 = new DataInOut();
                            data_431.writeLong(v_432.getTime());
                            serializeContextVar_381.sendResultToRemote(requestId_427,data_431.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 11:  {
                        int requestId_433 = in_.readInt();
                        String[] argsNames_434 = new String[] {
                            
                        };
                        Object[] argsValues_435 = new Object[] {
                            
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("unblock", argsNames_434, argsValues_435);
                        serializeContextVar_381.regLocalFuture();
                        var result_436 = localApi.unblock();
                        serializeContextVar_381.invokeLocalMethodAfter("unblock", result_436, argsNames_434, argsValues_435);
                        result_436.to(()-> {
                            var data_437 = new DataInOut();
                            serializeContextVar_381.sendResultToRemote(requestId_433);
                            
                        }
                        );
                        break;
                        
                    }
                    case 12:  {
                        int requestId_438 = in_.readInt();
                        String[] argsNames_439 = new String[] {
                            
                        };
                        Object[] argsValues_440 = new Object[] {
                            
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("createTime", argsNames_439, argsValues_440);
                        serializeContextVar_381.regLocalFuture();
                        var result_441 = localApi.createTime();
                        serializeContextVar_381.invokeLocalMethodAfter("createTime", result_441, argsNames_439, argsValues_440);
                        result_441.to((v_443)-> {
                            var data_442 = new DataInOut();
                            data_442.writeLong(v_443.getTime());
                            serializeContextVar_381.sendResultToRemote(requestId_438,data_442.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 13:  {
                        int requestId_444 = in_.readInt();
                        String[] argsNames_445 = new String[] {
                            
                        };
                        Object[] argsValues_446 = new Object[] {
                            
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("onlineTime", argsNames_445, argsValues_446);
                        serializeContextVar_381.regLocalFuture();
                        var result_447 = localApi.onlineTime();
                        serializeContextVar_381.invokeLocalMethodAfter("onlineTime", result_447, argsNames_445, argsValues_446);
                        result_447.to((v_449)-> {
                            var data_448 = new DataInOut();
                            data_448.writeLong(v_449.getTime());
                            serializeContextVar_381.sendResultToRemote(requestId_444,data_448.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 14:  {
                        int requestId_450 = in_.readInt();
                        long groupId_451;
                        groupId_451=in_.readLong();
                        String[] argsNames_452 = new String[] {
                            "groupId"
                        };
                        Object[] argsValues_453 = new Object[] {
                            groupId_451
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("addAccessGroup", argsNames_452, argsValues_453);
                        serializeContextVar_381.regLocalFuture();
                        var result_454 = localApi.addAccessGroup(groupId_451);
                        serializeContextVar_381.invokeLocalMethodAfter("addAccessGroup", result_454, argsNames_452, argsValues_453);
                        result_454.to((v_456)-> {
                            var data_455 = new DataInOut();
                            data_455.writeByte(v_456?1:0);
                            serializeContextVar_381.sendResultToRemote(requestId_450,data_455.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 15:  {
                        int requestId_457 = in_.readInt();
                        long groupId_458;
                        groupId_458=in_.readLong();
                        String[] argsNames_459 = new String[] {
                            "groupId"
                        };
                        Object[] argsValues_460 = new Object[] {
                            groupId_458
                        };
                        serializeContextVar_381.invokeLocalMethodBefore("removeAccessGroup", argsNames_459, argsValues_460);
                        serializeContextVar_381.regLocalFuture();
                        var result_461 = localApi.removeAccessGroup(groupId_458);
                        serializeContextVar_381.invokeLocalMethodAfter("removeAccessGroup", result_461, argsNames_459, argsValues_460);
                        result_461.to((v_463)-> {
                            var data_462 = new DataInOut();
                            data_462.writeByte(v_463?1:0);
                            serializeContextVar_381.sendResultToRemote(requestId_457,data_462.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public ServerApiByUidRemote makeRemote(FastFutureContext localApi_465) {
            return new ServerApiByUidRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_465.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_465;
                    
                }
                @Override public @Command(3) ARFuture<Long> getBalance() {
                    var dataOut_466 = new DataInOut();
                    dataOut_466.writeByte(3);
                    String[] argsNames_468 = new String[] {
                        
                    };
                    Object[] argsValues_469 = new Object[] {
                        
                    };
                    var result_467 = ARFuture.<Long>of();
                    localApi_465.invokeRemoteMethodAfter("getBalance", result_467, argsNames_468, argsValues_469);
                    var requestId_470 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_467.done(FastMeta.META_LONG.deserialize(localApi_465,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_467.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_466.writeInt(requestId_470);
                    localApi_465.sendToRemote(dataOut_466.toArray());
                    return result_467;
                    
                }
                @Override public @Command(4) AFuture setParent(UUID uid) {
                    var dataOut_471 = new DataInOut();
                    dataOut_471.writeByte(4);
                    String[] argsNames_473 = new String[] {
                        "uid"
                    };
                    Object[] argsValues_474 = new Object[] {
                        uid
                    };
                    var result_472 = AFuture.make();
                    localApi_465.invokeRemoteMethodAfter("setParent", result_472, argsNames_473, argsValues_474);
                    var requestId_475 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_472.done();
                            
                        }
                        public void onError(DataIn in) {
                            result_472.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_471.writeInt(requestId_475);
                    FastMeta.META_UUID.serialize(localApi_465,uid,dataOut_471);
                    localApi_465.sendToRemote(dataOut_471.toArray());
                    return result_472;
                    
                }
                @Override public @Command(5) AFuture block() {
                    var dataOut_476 = new DataInOut();
                    dataOut_476.writeByte(5);
                    String[] argsNames_478 = new String[] {
                        
                    };
                    Object[] argsValues_479 = new Object[] {
                        
                    };
                    var result_477 = AFuture.make();
                    localApi_465.invokeRemoteMethodAfter("block", result_477, argsNames_478, argsValues_479);
                    var requestId_480 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_477.done();
                            
                        }
                        public void onError(DataIn in) {
                            result_477.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_476.writeInt(requestId_480);
                    localApi_465.sendToRemote(dataOut_476.toArray());
                    return result_477;
                    
                }
                @Override public @Command(6) ARFuture<Cloud> getPosition() {
                    var dataOut_481 = new DataInOut();
                    dataOut_481.writeByte(6);
                    String[] argsNames_483 = new String[] {
                        
                    };
                    Object[] argsValues_484 = new Object[] {
                        
                    };
                    var result_482 = ARFuture.<Cloud>of();
                    localApi_465.invokeRemoteMethodAfter("getPosition", result_482, argsNames_483, argsValues_484);
                    var requestId_485 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_482.done(Cloud.META.deserialize(localApi_465,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_482.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_481.writeInt(requestId_485);
                    localApi_465.sendToRemote(dataOut_481.toArray());
                    return result_482;
                    
                }
                @Override public @Command(7) ARFuture<UUID> getParent() {
                    var dataOut_486 = new DataInOut();
                    dataOut_486.writeByte(7);
                    String[] argsNames_488 = new String[] {
                        
                    };
                    Object[] argsValues_489 = new Object[] {
                        
                    };
                    var result_487 = ARFuture.<UUID>of();
                    localApi_465.invokeRemoteMethodAfter("getParent", result_487, argsNames_488, argsValues_489);
                    var requestId_490 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_487.done(FastMeta.META_UUID.deserialize(localApi_465,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_487.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_486.writeInt(requestId_490);
                    localApi_465.sendToRemote(dataOut_486.toArray());
                    return result_487;
                    
                }
                @Override public @Command(8) ARFuture<UUID> getBeneficiary() {
                    var dataOut_491 = new DataInOut();
                    dataOut_491.writeByte(8);
                    String[] argsNames_493 = new String[] {
                        
                    };
                    Object[] argsValues_494 = new Object[] {
                        
                    };
                    var result_492 = ARFuture.<UUID>of();
                    localApi_465.invokeRemoteMethodAfter("getBeneficiary", result_492, argsNames_493, argsValues_494);
                    var requestId_495 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_492.done(FastMeta.META_UUID.deserialize(localApi_465,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_492.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_491.writeInt(requestId_495);
                    localApi_465.sendToRemote(dataOut_491.toArray());
                    return result_492;
                    
                }
                @Override public @Command(9) AFuture setBeneficiary(UUID uid) {
                    var dataOut_496 = new DataInOut();
                    dataOut_496.writeByte(9);
                    String[] argsNames_498 = new String[] {
                        "uid"
                    };
                    Object[] argsValues_499 = new Object[] {
                        uid
                    };
                    var result_497 = AFuture.make();
                    localApi_465.invokeRemoteMethodAfter("setBeneficiary", result_497, argsNames_498, argsValues_499);
                    var requestId_500 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_497.done();
                            
                        }
                        public void onError(DataIn in) {
                            result_497.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_496.writeInt(requestId_500);
                    FastMeta.META_UUID.serialize(localApi_465,uid,dataOut_496);
                    localApi_465.sendToRemote(dataOut_496.toArray());
                    return result_497;
                    
                }
                @Override public @Command(10) ARFuture<java.util.Date> getBlockTime() {
                    var dataOut_501 = new DataInOut();
                    dataOut_501.writeByte(10);
                    String[] argsNames_503 = new String[] {
                        
                    };
                    Object[] argsValues_504 = new Object[] {
                        
                    };
                    var result_502 = ARFuture.<java.util.Date>of();
                    localApi_465.invokeRemoteMethodAfter("getBlockTime", result_502, argsNames_503, argsValues_504);
                    var requestId_505 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_502.done(FastMeta.META_DATE.deserialize(localApi_465,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_502.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_501.writeInt(requestId_505);
                    localApi_465.sendToRemote(dataOut_501.toArray());
                    return result_502;
                    
                }
                @Override public @Command(11) AFuture unblock() {
                    var dataOut_506 = new DataInOut();
                    dataOut_506.writeByte(11);
                    String[] argsNames_508 = new String[] {
                        
                    };
                    Object[] argsValues_509 = new Object[] {
                        
                    };
                    var result_507 = AFuture.make();
                    localApi_465.invokeRemoteMethodAfter("unblock", result_507, argsNames_508, argsValues_509);
                    var requestId_510 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_507.done();
                            
                        }
                        public void onError(DataIn in) {
                            result_507.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_506.writeInt(requestId_510);
                    localApi_465.sendToRemote(dataOut_506.toArray());
                    return result_507;
                    
                }
                @Override public @Command(12) ARFuture<java.util.Date> createTime() {
                    var dataOut_511 = new DataInOut();
                    dataOut_511.writeByte(12);
                    String[] argsNames_513 = new String[] {
                        
                    };
                    Object[] argsValues_514 = new Object[] {
                        
                    };
                    var result_512 = ARFuture.<java.util.Date>of();
                    localApi_465.invokeRemoteMethodAfter("createTime", result_512, argsNames_513, argsValues_514);
                    var requestId_515 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_512.done(FastMeta.META_DATE.deserialize(localApi_465,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_512.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_511.writeInt(requestId_515);
                    localApi_465.sendToRemote(dataOut_511.toArray());
                    return result_512;
                    
                }
                @Override public @Command(13) ARFuture<java.util.Date> onlineTime() {
                    var dataOut_516 = new DataInOut();
                    dataOut_516.writeByte(13);
                    String[] argsNames_518 = new String[] {
                        
                    };
                    Object[] argsValues_519 = new Object[] {
                        
                    };
                    var result_517 = ARFuture.<java.util.Date>of();
                    localApi_465.invokeRemoteMethodAfter("onlineTime", result_517, argsNames_518, argsValues_519);
                    var requestId_520 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_517.done(FastMeta.META_DATE.deserialize(localApi_465,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_517.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_516.writeInt(requestId_520);
                    localApi_465.sendToRemote(dataOut_516.toArray());
                    return result_517;
                    
                }
                @Override public @Command(14) ARFuture<Boolean> addAccessGroup(long groupId) {
                    var dataOut_521 = new DataInOut();
                    dataOut_521.writeByte(14);
                    String[] argsNames_523 = new String[] {
                        "groupId"
                    };
                    Object[] argsValues_524 = new Object[] {
                        groupId
                    };
                    var result_522 = ARFuture.<Boolean>of();
                    localApi_465.invokeRemoteMethodAfter("addAccessGroup", result_522, argsNames_523, argsValues_524);
                    var requestId_525 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_522.done(FastMeta.META_BOOLEAN.deserialize(localApi_465,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_522.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_521.writeInt(requestId_525);
                    dataOut_521.writeLong(groupId);
                    localApi_465.sendToRemote(dataOut_521.toArray());
                    return result_522;
                    
                }
                @Override public @Command(15) ARFuture<Boolean> removeAccessGroup(long groupId) {
                    var dataOut_526 = new DataInOut();
                    dataOut_526.writeByte(15);
                    String[] argsNames_528 = new String[] {
                        "groupId"
                    };
                    Object[] argsValues_529 = new Object[] {
                        groupId
                    };
                    var result_527 = ARFuture.<Boolean>of();
                    localApi_465.invokeRemoteMethodAfter("removeAccessGroup", result_527, argsNames_528, argsValues_529);
                    var requestId_530 = localApi_465.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_527.done(FastMeta.META_BOOLEAN.deserialize(localApi_465,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_527.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_526.writeInt(requestId_530);
                    dataOut_526.writeLong(groupId);
                    localApi_465.sendToRemote(dataOut_526.toArray());
                    return result_527;
                    
                }
                
            };
            
        }
        
    };
    @Command(3) ARFuture<Long> getBalance();
    @Command(4) AFuture setParent(UUID uid);
    @Command(5) AFuture block();
    @Command(6) ARFuture<Cloud> getPosition();
    @Command(7) ARFuture<UUID> getParent();
    @Command(8) ARFuture<UUID> getBeneficiary();
    @Command(9) AFuture setBeneficiary(UUID uid);
    @Command(10) ARFuture<java.util.Date> getBlockTime();
    @Command(11) AFuture unblock();
    @Command(12) ARFuture<java.util.Date> createTime();
    @Command(13) ARFuture<java.util.Date> onlineTime();
    @Command(14) ARFuture<Boolean> addAccessGroup(long groupId);
    @Command(15) ARFuture<Boolean> removeAccessGroup(long groupId);
    
}

=== Файл: ServerApiByUidLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class ServerApiByUidLocal<RT> implements ServerApiByUid {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected ServerApiByUidLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: ServerApiByUidRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ServerApiByUidRemote extends ServerApiByUid, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: ServerRegistrationApi.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ServerRegistrationApi  {
    FastMetaApi<ServerRegistrationApi,ServerRegistrationApiRemote> META=new FastMetaApi<>() {
        public void makeLocal(FastFutureContext serializeContextVar_74, DataIn in_, ServerRegistrationApi localApi) {
            while(in_.isReadable()) {
                byte commandId = in_.readByte();
                switch(commandId)  {
                    case 0: {
                        var requestId_75 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_74,in_);
                        var futureRec_76 = serializeContextVar_74.getFuture(requestId_75);
                        if(futureRec_76 != null) futureRec_76.onDone(in_);
                        break;
                        
                    }
                    case 1: {
                        var requestId_77 = FastMeta.META_REQUEST_ID.deserialize(serializeContextVar_74,in_);
                        var futureRec_78 = serializeContextVar_74.getFuture(requestId_77);
                        if(futureRec_78 != null) futureRec_78.onError(in_);
                        break;
                        
                    }
                    case 3:  {
                        String salt_80;
                        String suffix_81;
                        int[] passwords_82;
                        UUID parent_83;
                        Key returnKey_84;
                        GlobalApiStream globalApi_85;
                        byte[] stringData_86;
                        var arraySize_87 = DeserializerPackNumber.INSTANCE.put(in_).intValue();
                        stringData_86=new byte[arraySize_87];
                        in_.read(stringData_86);
                        salt_80=new String(stringData_86);
                        byte[] stringData_88;
                        var arraySize_89 = DeserializerPackNumber.INSTANCE.put(in_).intValue();
                        stringData_88=new byte[arraySize_89];
                        in_.read(stringData_88);
                        suffix_81=new String(stringData_88);
                        var arraySize_90 = DeserializerPackNumber.INSTANCE.put(in_).intValue();
                        passwords_82=new int[arraySize_90];
                        for(var forVar_91=0; forVar_91<arraySize_90; forVar_91++) {
                            passwords_82[forVar_91]=in_.readInt();
                            
                        }
                        parent_83=FastMeta.META_UUID.deserialize(serializeContextVar_74,in_);
                        returnKey_84=Key.META.deserialize(serializeContextVar_74,in_);
                        globalApi_85=GlobalApiStream.META.deserialize(serializeContextVar_74,in_);
                        String[] argsNames_92 = new String[] {
                            "salt", "suffix", "passwords", "parent", "returnKey", "globalApi"
                        };
                        Object[] argsValues_93 = new Object[] {
                            salt_80, suffix_81, passwords_82, parent_83, returnKey_84, globalApi_85
                        };
                        serializeContextVar_74.invokeLocalMethodBefore("registration", argsNames_92, argsValues_93);
                        localApi.registration(salt_80,suffix_81,passwords_82,parent_83,returnKey_84,globalApi_85);
                        serializeContextVar_74.invokeLocalMethodAfter("registration", null, argsNames_92, argsValues_93);
                        break;
                        
                    }
                    case 4:  {
                        int requestId_94 = in_.readInt();
                        UUID parent_95;
                        PowMethod powMethods_96;
                        Key returnKey_97;
                        parent_95=FastMeta.META_UUID.deserialize(serializeContextVar_74,in_);
                        powMethods_96=PowMethod.META.deserialize(serializeContextVar_74,in_);
                        returnKey_97=Key.META.deserialize(serializeContextVar_74,in_);
                        String[] argsNames_98 = new String[] {
                            "parent", "powMethods", "returnKey"
                        };
                        Object[] argsValues_99 = new Object[] {
                            parent_95, powMethods_96, returnKey_97
                        };
                        serializeContextVar_74.invokeLocalMethodBefore("requestWorkProofData", argsNames_98, argsValues_99);
                        serializeContextVar_74.regLocalFuture();
                        var result_100 = localApi.requestWorkProofData(parent_95,powMethods_96,returnKey_97);
                        serializeContextVar_74.invokeLocalMethodAfter("requestWorkProofData", result_100, argsNames_98, argsValues_99);
                        result_100.to((v_102)-> {
                            var data_101 = new DataInOut();
                            WorkProofDTO.META.serialize(serializeContextVar_74,v_102,data_101);
                            serializeContextVar_74.sendResultToRemote(requestId_94,data_101.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    case 5:  {
                        int requestId_103 = in_.readInt();
                        Cloud serverIds_104;
                        serverIds_104=Cloud.META.deserialize(serializeContextVar_74,in_);
                        String[] argsNames_105 = new String[] {
                            "serverIds"
                        };
                        Object[] argsValues_106 = new Object[] {
                            serverIds_104
                        };
                        serializeContextVar_74.invokeLocalMethodBefore("resolveServers", argsNames_105, argsValues_106);
                        serializeContextVar_74.regLocalFuture();
                        var result_107 = localApi.resolveServers(serverIds_104);
                        serializeContextVar_74.invokeLocalMethodAfter("resolveServers", result_107, argsNames_105, argsValues_106);
                        result_107.to((v_109)-> {
                            var data_108 = new DataInOut();
                            SerializerPackNumber.INSTANCE.put(data_108,v_109.length);
                            for(var forVar_110:v_109) {
                                ServerDescriptor.META.serialize(serializeContextVar_74,forVar_110,data_108);
                                
                            }
                            serializeContextVar_74.sendResultToRemote(requestId_103,data_108.toArray());
                            
                        }
                        );
                        break;
                        
                    }
                    default: throw new IllegalArgumentException("Unknown command ID: " + commandId);
                    
                }
                
            }
            
        }
        public ServerRegistrationApiRemote makeRemote(FastFutureContext localApi_112) {
            return new ServerRegistrationApiRemote() {
                @Override public void flush(AFuture sendFuture) {
                    localApi_112.flush(sendFuture);
                    
                }
                public io.aether.net.fastMeta.FastFutureContext getFastMetaContext() {
                    return localApi_112;
                    
                }
                @Override public @Command(3) void registration(String salt, String suffix, int[] passwords, UUID parent, Key returnKey, GlobalApiStream globalApi) {
                    var dataOut_113 = new DataInOut();
                    dataOut_113.writeByte(3);
                    String[] argsNames_115 = new String[] {
                        "salt", "suffix", "passwords", "parent", "returnKey", "globalApi"
                    };
                    Object[] argsValues_116 = new Object[] {
                        salt, suffix, passwords, parent, returnKey, globalApi
                    };
                    localApi_112.invokeRemoteMethodAfter("registration", null, argsNames_115, argsValues_116);
                    var stringData_117=salt.getBytes();
                    SerializerPackNumber.INSTANCE.put(dataOut_113,stringData_117.length);
                    dataOut_113.write(stringData_117);
                    var stringData_118=suffix.getBytes();
                    SerializerPackNumber.INSTANCE.put(dataOut_113,stringData_118.length);
                    dataOut_113.write(stringData_118);
                    SerializerPackNumber.INSTANCE.put(dataOut_113,passwords.length);
                    for(var forVar_119:passwords) {
                        dataOut_113.writeInt(forVar_119);
                        
                    }
                    FastMeta.META_UUID.serialize(localApi_112,parent,dataOut_113);
                    Key.META.serialize(localApi_112,returnKey,dataOut_113);
                    GlobalApiStream.META.serialize(localApi_112,globalApi,dataOut_113);
                    localApi_112.sendToRemote(dataOut_113.toArray());
                    
                }
                @Override public @Command(4) ARFuture<WorkProofDTO> requestWorkProofData(UUID parent, PowMethod powMethods, Key returnKey) {
                    var dataOut_120 = new DataInOut();
                    dataOut_120.writeByte(4);
                    String[] argsNames_122 = new String[] {
                        "parent", "powMethods", "returnKey"
                    };
                    Object[] argsValues_123 = new Object[] {
                        parent, powMethods, returnKey
                    };
                    var result_121 = ARFuture.<WorkProofDTO>of();
                    localApi_112.invokeRemoteMethodAfter("requestWorkProofData", result_121, argsNames_122, argsValues_123);
                    var requestId_124 = localApi_112.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_121.done(WorkProofDTO.META.deserialize(localApi_112,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_121.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_120.writeInt(requestId_124);
                    FastMeta.META_UUID.serialize(localApi_112,parent,dataOut_120);
                    PowMethod.META.serialize(localApi_112,powMethods,dataOut_120);
                    Key.META.serialize(localApi_112,returnKey,dataOut_120);
                    localApi_112.sendToRemote(dataOut_120.toArray());
                    return result_121;
                    
                }
                @Override public @Command(5) ARFuture<ServerDescriptor[]> resolveServers(Cloud serverIds) {
                    var dataOut_125 = new DataInOut();
                    dataOut_125.writeByte(5);
                    String[] argsNames_127 = new String[] {
                        "serverIds"
                    };
                    Object[] argsValues_128 = new Object[] {
                        serverIds
                    };
                    var result_126 = ARFuture.<ServerDescriptor[]>of();
                    localApi_112.invokeRemoteMethodAfter("resolveServers", result_126, argsNames_127, argsValues_128);
                    var requestId_129 = localApi_112.regFuture(new FutureRec() {
                        public void onDone(DataIn in) {
                            result_126.done(ClientServerRegApiMeta.META_ARRAY_ServerDescriptor.deserialize(localApi_112,in));
                            
                        }
                        public void onError(DataIn in) {
                            result_126.error(new AetherException("Remote call failed without a typed exception"));
                            
                        }
                        
                    }
                    );
                    dataOut_125.writeInt(requestId_129);
                    Cloud.META.serialize(localApi_112,serverIds,dataOut_125);
                    localApi_112.sendToRemote(dataOut_125.toArray());
                    return result_126;
                    
                }
                
            };
            
        }
        
    };
    @Command(3) void registration(String salt, String suffix, int[] passwords, UUID parent, Key returnKey, GlobalApiStream globalApi);
    @Command(4) ARFuture<WorkProofDTO> requestWorkProofData(UUID parent, PowMethod powMethods, Key returnKey);
    @Command(5) ARFuture<ServerDescriptor[]> resolveServers(Cloud serverIds);
    
}

=== Файл: ServerRegistrationApiLocal.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class ServerRegistrationApiLocal<RT> implements ServerRegistrationApi {
    protected final RT remoteApi;
    public RT getRemoteApi() {
        return this.remoteApi;
        
    };
    protected ServerRegistrationApiLocal(RT remoteApi) {
        this.remoteApi=remoteApi;
        
    }
    
}

=== Файл: ServerRegistrationApiRemote.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public interface ServerRegistrationApiRemote extends ServerRegistrationApi, io.aether.net.fastMeta.RemoteApi  {
    
}

=== Файл: ServerRegistrationApiStream.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public class ServerRegistrationApiStream implements io.aether.utils.ToString  {
    public static final FastMetaType<ServerRegistrationApiStream> META = new FastMetaType<>()  {
        @Override public void serialize(FastFutureContext ctx, ServerRegistrationApiStream obj, DataOut out)  {
            FastMeta.META_ARRAY_BYTE.serialize(ctx, obj.data, out);
            
        }
        @Override public ServerRegistrationApiStream deserialize(FastFutureContext ctx, DataIn in)  {
            return new ServerRegistrationApiStream(FastMeta.META_ARRAY_BYTE.deserialize(ctx, in));
            
        }
        
    };
    public final byte[] data;
    public ServerRegistrationApiStream(byte[] data)  {
        this.data = data;
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("ServerRegistrationApiStream(");
        sb.add("data[").add(this.data.length).add("]:").add(this.data);
        sb.add(')');
        
    }
    public void accept(FastFutureContext context, BytesConverter provider, ServerRegistrationApi localApi)  {
        byte[] decryptedData = provider.apply(this.data);
        ServerRegistrationApi.META.makeLocal(context, new DataInOutStatic(decryptedData), localApi);
        
    }
    public void accept(FastApiContextLocal<? extends ServerRegistrationApi> context, BytesConverter provider)  {
        accept(context, provider, context.localApi);
        
    }
    public void accept(BytesConverter provider, ServerRegistrationApi localApi)  {
        accept(((FastFutureContextGetter)localApi).getFastFutureContext(),provider,localApi);
        
    }
    public ServerRegistrationApiStream(FastFutureContext context,BytesConverter provider, io.aether.net.fastMeta.RemoteApiFuture<ServerRegistrationApiRemote> remote, AFuture sendFuture)  {
        remote.executeAll(context, sendFuture);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public ServerRegistrationApiStream(FastFutureContext context,BytesConverter provider, AConsumer<ServerRegistrationApiRemote> remote)  {
        var api= ServerRegistrationApi.META.makeRemote(context);
        remote.accept(api);
        this.data=provider.apply(context.remoteDataToArray());
        
    }
    public ServerRegistrationApiStream(BytesConverter provider, byte[] remoteData)  {
        this.data=provider.apply(remoteData);
        
    }
    public ServerRegistrationApiStream(FastFutureContextGetter context,BytesConverter provider, AConsumer<ServerRegistrationApiRemote> remote)  {
        this(context.getFastFutureContext(),provider, remote);
        
    }
    
}

=== Файл: TelemetryCPP.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public class TelemetryCPP extends Telemetry implements io.aether.utils.ToString  {
    @Override public int getAetherTypeId() {
        return 0;
        
    }
    public static final FastMetaType<TelemetryCPP> META_BODY = new FastMetaType<>() {
        @Override public void serialize(FastFutureContext serializeContextVar_4, TelemetryCPP obj_5, DataOut out_6) {
            out_6.writeInt(obj_5.utm_id);
            SerializerPackNumber.INSTANCE.put(out_6,obj_5.blob.length);
            out_6.write(obj_5.blob);
            var stringData_8=obj_5.lib_version.getBytes();
            SerializerPackNumber.INSTANCE.put(out_6,stringData_8.length);
            out_6.write(stringData_8);
            var stringData_9=obj_5.os.getBytes();
            SerializerPackNumber.INSTANCE.put(out_6,stringData_9.length);
            out_6.write(stringData_9);
            var stringData_10=obj_5.compiler.getBytes();
            SerializerPackNumber.INSTANCE.put(out_6,stringData_10.length);
            out_6.write(stringData_10);
            
        }
        @Override public TelemetryCPP deserialize(FastFutureContext serializeContextVar_4, DataIn in_7) {
            int utm_id_11;
            byte[] blob_12;
            String lib_version_13;
            String os_14;
            String compiler_15;
            utm_id_11=in_7.readInt();
            var arraySize_16 = DeserializerPackNumber.INSTANCE.put(in_7).intValue();
            blob_12=new byte[arraySize_16];
            in_7.read(blob_12);
            byte[] stringData_17;
            var arraySize_18 = DeserializerPackNumber.INSTANCE.put(in_7).intValue();
            stringData_17=new byte[arraySize_18];
            in_7.read(stringData_17);
            lib_version_13=new String(stringData_17);
            byte[] stringData_19;
            var arraySize_20 = DeserializerPackNumber.INSTANCE.put(in_7).intValue();
            stringData_19=new byte[arraySize_20];
            in_7.read(stringData_19);
            os_14=new String(stringData_19);
            byte[] stringData_21;
            var arraySize_22 = DeserializerPackNumber.INSTANCE.put(in_7).intValue();
            stringData_21=new byte[arraySize_22];
            in_7.read(stringData_21);
            compiler_15=new String(stringData_21);
            return new TelemetryCPP(utm_id_11,blob_12,lib_version_13,os_14,compiler_15);
            
        }
        
    };
    public static final FastMetaType<TelemetryCPP> META = new FastMetaType<>() {
        @Override public void serialize(FastFutureContext serializeContextVar_23, TelemetryCPP obj_24, DataOut out_25) {
            TelemetryCPP.META_BODY.serialize(serializeContextVar_23, obj_24, out_25);
            
        }
        @Override public TelemetryCPP deserialize(FastFutureContext serializeContextVar_23, DataIn in_26) {
            return TelemetryCPP.META_BODY.deserialize(serializeContextVar_23, in_26);
            
        }
        
    };
    protected final int utm_id;
    protected final byte[] blob;
    protected final String lib_version;
    protected final String os;
    protected final String compiler;
    public TelemetryCPP(int utm_id, byte[] blob, String lib_version, String os, String compiler)  {
        if (blob == null)  {
            throw new java.lang.NullPointerException("Field 'blob' cannot be null.");
            
        }
        this.utm_id = utm_id;
        this.blob = blob;
        this.lib_version = lib_version;
        this.os = os;
        this.compiler = compiler;
        
    }
    public int getUtm_id()  {
        return this.utm_id;
        
    }
    public byte[] getBlob()  {
        return this.blob;
        
    }
    public boolean blobContains(byte el)  {
        return ByteSet.of(this.blob).contains(el);
        
    }
    public String getLib_version()  {
        return this.lib_version;
        
    }
    public String getOs()  {
        return this.os;
        
    }
    public String getCompiler()  {
        return this.compiler;
        
    }
    @Override public boolean equals(Object o)  {
        if (this == o) return true;
        if (o == null || !(o instanceof TelemetryCPP)) return false;
        TelemetryCPP that = (TelemetryCPP) o;
        return java.util.Objects.equals(this.utm_id, that.utm_id) && java.util.Arrays.equals(this.blob, that.blob) && java.util.Objects.equals(this.lib_version, that.lib_version) && java.util.Objects.equals(this.os, that.os) && java.util.Objects.equals(this.compiler, that.compiler);
        
    }
    @Override public int hashCode()  {
        return java.util.Objects.hash(this.utm_id, java.util.Arrays.hashCode(this.blob), this.lib_version, this.os, this.compiler);
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("TelemetryCPP(");
        sb.add("utm_id:");
        sb.add(this.utm_id);
        sb.add(", ");
        sb.add("blob:");
        sb.add(this.blob);
        sb.add(", ");
        sb.add("lib_version:");
        sb.add(this.lib_version);
        sb.add(", ");
        sb.add("os:");
        sb.add(this.os);
        sb.add(", ");
        sb.add("compiler:");
        sb.add(this.compiler);
        sb.add(')');
        
    }
    
}

=== Файл: Telemetry.java ===
package io.aether.api.clientserverregapi;
import io.aether.api.common.*;
import java.net.URI;
import java.net.URISyntaxException;
import io.aether.net.fastMeta.FastMetaType;
import java.util.UUID;
import java.util.Date;
import io.aether.net.fastMeta.BytesConverter;
import java.io.Closeable;
import io.aether.net.fastMeta.*;
import io.aether.utils.dataio.DataIn;
import io.aether.utils.dataio.DataOut;
import io.aether.utils.dataio.DataInOutStatic;
import io.aether.utils.dataio.DataInOut;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import it.unimi.dsi.fastutil.bytes.ByteSet;
import it.unimi.dsi.fastutil.doubles.DoubleSet;
import it.unimi.dsi.fastutil.floats.FloatSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import it.unimi.dsi.fastutil.longs.LongSet;
import it.unimi.dsi.fastutil.shorts.ShortSet;
import io.aether.utils.interfaces.AConsumer;
import io.aether.utils.futures.AFuture;
import io.aether.utils.futures.ARFuture;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.util.*;
public abstract class Telemetry implements io.aether.utils.ToString  {
    public abstract int getUtm_id();
    public abstract byte[] getBlob();
    public abstract String getLib_version();
    public abstract String getOs();
    public abstract String getCompiler();
    public abstract int getAetherTypeId();
    public static final FastMetaType<Telemetry> META = new FastMetaType<>() {
        @Override public void serialize(FastFutureContext serializeContextVar_0, Telemetry obj_1, DataOut out_2) {
            out_2.writeByte(obj_1.getAetherTypeId());
            switch(obj_1.getAetherTypeId()) {
                case 0: TelemetryCPP.META_BODY.serialize(serializeContextVar_0, (TelemetryCPP)obj_1, out_2);
                break;
                default: throw new java.lang.IllegalStateException("Cannot serialize 'Telemetry' with unknown type id " + obj_1.getAetherTypeId());
                
            }
            
        }
        @Override public Telemetry deserialize(FastFutureContext serializeContextVar_0, DataIn in_3) {
            var typeId = in_3.readUByte();
            switch(typeId) {
                case 0: return (Telemetry)TelemetryCPP.META_BODY.deserialize(serializeContextVar_0,in_3);
                default: throw new java.lang.IllegalStateException("Bad type id "+typeId + " for type 'Telemetry'");
                
            }
            
        }
        
    };
    public Telemetry()  {
        
    }
    @Override public boolean equals(Object o)  {
        if (this == o) return true;
        if (o == null || !(o instanceof Telemetry)) return false;
        Telemetry that = (Telemetry) o;
        return true;
        
    }
    @Override public int hashCode()  {
        return 0;
        
    }
    @Override public void toString(io.aether.utils.AString sb)  {
        sb.add("Telemetry(");
        sb.add(')');
        
    }
    
}

