encoder.writeSmallInt(daemonParameters.getIdleTimeout());
            encoder.writeSmallInt(daemonParameters.getPeriodicCheckInterval());
            encoder.writeBoolean(singleUse);
            encoder.writeSmallInt(daemonParameters.getNativeServicesMode().ordinal());
            encoder.writeString(daemonUid);
            encoder.writeSmallInt(daemonParameters.getPriority().ordinal());

        writeSmallInt(count);
        writeBytes(bytes, offset, count);
    }

    @Override
    public void encodeChunked(EncodeAction<Encoder> writeAction) throws Exception {
        throw new UnsupportedOperationException();
    }

    @Override
    public void writeSmallInt(int value) throws IOException {
        writeInt(value);
    }

    @Override

                methods.put(method, methodDetails);
                encoder.writeSmallInt(methodId);
                encoder.writeString(method.getDeclaringClass().getName());
                encoder.writeString(method.getName());
                encoder.writeSmallInt(method.getParameterTypes().length);
                for (int i = 0; i < method.getParameterTypes().length; i++) {

    public void write(Encoder encoder, IntQuestionPromptEvent value) throws Exception {
        encoder.writeLong(value.getTimestamp());
        encoder.writeString(value.getQuestion());
        encoder.writeSmallInt(value.getMinValue());
        encoder.writeSmallInt(value.getDefaultValue());
    }

    @Override
    public IntQuestionPromptEvent read(Decoder decoder) throws Exception {

        } else {
            encoder.writeByte((byte) 1);
            encoder.writeSmallInt(dependentsSet.getPrivateDependentClasses().size());
            for (String className : dependentsSet.getPrivateDependentClasses()) {
                nameSerializer.write(encoder, className);
            }
            encoder.writeSmallInt(dependentsSet.getAccessibleDependentClasses().size());

        if (variant == null) {
            encoder.writeSmallInt(-1);
            return;
        }
        Integer index = written.get(variant);
        if (index == null) {
            index = written.size();
            written.put(variant, index);
            encoder.writeSmallInt(index);
            componentIdentifierSerializer.write(encoder, variant.getOwner());

        return componentSelectorSerializer;
    }

    public void writeRealisedVariantsData(Encoder encoder, AbstractRealisedModuleComponentResolveMetadata transformed) throws IOException {
        encoder.writeSmallInt(transformed.getVariants().size());
        for (ComponentVariant variant: transformed.getVariants()) {
            if (variant instanceof AbstractRealisedModuleComponentResolveMetadata.ImmutableRealisedVariantImpl) {

                channelNum = channels.size();
                channels.put(channelMessage.getChannel(), channelNum);
                encoder.writeSmallInt(channelNum);
                encoder.writeString(channelMessage.getChannel().getName());
            } else {
                encoder.writeSmallInt(channelNum);
            }
        }
    }

            // Parallel configuration
            encoder.writeBoolean(startParameter.isParallelProjectExecutionEnabled());
            encoder.writeSmallInt(startParameter.getMaxWorkerCount());

            // Tasks
            writeTaskRequests(encoder, startParameter.getTaskRequests());
            stringSetSerializer.write(encoder, startParameter.getExcludedTaskNames());

                if (USUAL_TYPES[i].equals(anyType)) {
                    encoder.writeSmallInt(i);
                    serializer.write(encoder, value);
                    return;
                }
            }
            encoder.writeSmallInt(-2);
            encoder.writeString(anyType.getName());
            serializer.write(encoder, value);
        }
    }