override fun encodingForType(type: Class<*>): Encoding? =
        EnumEncoding.takeIf { type.isEnum }
            ?: EnumSubTypeEncoding.takeIf { type.superclass?.isEnum == true }

    override suspend fun ReadContext.decode(): Any? {
        val enumClass = readClass()
        val enumOrdinal = readSmallInt()
        return enumClass.enumConstants[enumOrdinal]
    }
}


private
object EnumEncoding : Encoding {

        writeReference(findOwningScript(value))
        writeReference(value.thisObject)
        encodeBean(value.dehydrate())
    }

    override suspend fun ReadContext.decode(): Closure<*> {
        val owner = readReference()
        val thisObject = readReference()

        return (decodeBean() as Closure<*>).rehydrate(null, owner, thisObject)
    }

    /**

		Result bool `json:"result"`
	}

	respBody := bytes.NewReader(opaRespBytes)

	var result opaResult
	if err = json.NewDecoder(respBody).Decode(&result); err != nil {
		respBody.Seek(0, 0)
		var resultAllow opaResultAllow
		if err = json.NewDecoder(respBody).Decode(&resultAllow); err != nil {
			return false, err
		}
		return resultAllow.Result.Allow, nil
	}

	return result.Result, nil

        // and so this node does not do anything useful
        write(value.artifact)
    }

    override suspend fun ReadContext.decode(): DefaultResolvableArtifact.ResolveAction {
        val artifact = readNonNull<DefaultResolvableArtifact>()
        return DefaultResolvableArtifact.ResolveAction(artifact)
    }

    override suspend fun WriteContext.encode(value: TransformedExternalArtifactSet) {
        encodePreservingSharedIdentityOf(value) {
            write(value.result)
        }
    }

    override suspend fun ReadContext.decode(): TransformedExternalArtifactSet {
        return decodePreservingSharedIdentity {

            text(" with name ")
            reference(value.serviceDetails.name)
            text(" used at configuration time")
        }
    }

    override suspend fun ReadContext.decode(): BuildServiceProvider<*, *>? {
        logUnsupported("deserialize", BuildServiceProvider::class, documentationSection = DocumentationSection.NotYetImplementedBuildServiceInFingerprint)
        return null
    }
}

            codec.run {
                encodeContents(value)
            }
            writeBoolean(value.isFinalizing)
        }
    }

    override suspend fun ReadContext.decode(): ConfigurableFileCollection {
        return decodePreservingIdentity { id ->
            val contents = codec.run { decodeContents() }
            val fileCollection = fileCollectionFactory.configurableFiles()

        write(value.parameterObject)
        writeClass(value.implementationClass)
        writeBoolean(value.isCacheable)
    }

    override suspend fun ReadContext.decode(): DefaultTransform.IsolateTransformParameters? {
        val parameterObject: TransformParameters? = read()?.uncheckedCast()
        val implementationClass = readClass()
        val cacheable = readBoolean()

    override suspend fun WriteContext.encode(value: DefaultTransformUpstreamDependenciesResolver.FinalizeTransformDependencies) {
        write(value.selectedArtifacts())
    }

    override suspend fun ReadContext.decode(): DefaultTransformUpstreamDependenciesResolver.FinalizeTransformDependencies {
        val artifacts = readNonNull<FileCollectionInternal>()

            }
        }
        if (type.superclass != null) {
            return serviceType(type.superclass)
        }
        return null
    }

    override suspend fun ReadContext.decode(): Any? {
        return isolate.owner.service(readClass())
    }
}


internal
class OwnerServiceEncoding(val serviceType: Class<*>) : Encoding {
    override suspend fun WriteContext.encode(value: Any) {