public void ConfigureServices(IServiceCollection services)
{
    services
        .AddRouting()
        .AddGraphQLServer()
        .BindRuntimeType<string, StringType>()
        .AddQueryType<Query>();
}

public void ConfigureServices(IServiceCollection services)
{
    services
        .AddRouting()
        .AddGraphQLServer()
        .BindRuntimeType<byte[], ByteArrayType>()
        .AddQueryType<Query>();
}

services
   .AddGraphQLServer()
   ... // your configuration
   .AddType(new UuidType('D'));

Foo foo = context.Argument<Foo>("bar");

ValueKind kind = context.ArgumentKind("bar");

public enum ValueKind
{
    String,
    Integer,
    Float,
    Boolean,
    Enum,
    Object,
    Null
}

public class Query 
{
    public OffsetDateTime GetDateTime(OffsetDateTime offsetDateTime)
    {
        return offsetDateTime;
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services
        .AddGraphQLServer()
        .AddQueryType<Query>()
        .BindRuntimeType<OffsetDateTime, DateTimeType>()
        .AddTypeConverter<OffsetDateTime, DateTimeOffset>(
            x => x.ToDateTimeOffset())
        .AddTypeConverter<DateTimeOffset, OffsetDateTime>(
            x => OffsetDateTime.FromDateTimeOffset(x));
}

public sealed class CreditCardNumberType
    : ScalarType<string, StringValueNode>
{
    private readonly ICreditCardValidator _validator;
    /// Like all type system objects, Scalars have support for dependency injection
    public CreditCardNumberType(ICreditCardValidator validator)
        : base("CreditCardNumber")
    {
        _validator = validator;
        Description = "Represents a credit card number in the format of XXXX XXXX XXXX XXXX";
    }
    /// <summary>
    /// Checks if a incoming StringValueNode is valid. In this case the string value is only
    /// valid if it passes the credit card validation
    /// </summary>
    /// <param name="valueSyntax">The valueSyntax to validate</param>
    /// <returns>true if the value syntax holds a valid credit card number</returns>
    protected override bool IsInstanceOfType(StringValueNode valueSyntax)
    {
        return _validator.ValidateCreditCard(valueSyntax.Value);
    }
    /// <summary>
    /// Checks if a incoming string is valid. In this case the string value is only
    /// valid if it passes the credit card validation
    /// </summary>
    /// <param name="runtimeValue">The valueSyntax to validate</param>
    /// <returns>true if the value syntax holds a valid credit card number</returns>
    protected override bool IsInstanceOfType(string runtimeValue)
    {
        return _validator.ValidateCreditCard(runtimeValue);
    }
    /// <summary>
    /// Converts a StringValueNode to a string
    /// </summary>
    protected override string ParseLiteral(StringValueNode valueSyntax) =>
        valueSyntax.Value;
    /// <summary>
    /// Converts a string to a StringValueNode
    /// </summary>
    protected override StringValueNode ParseValue(string runtimeValue) =>
        new StringValueNode(runtimeValue);
    /// <summary>
    /// Parses a result value of this into a GraphQL value syntax representation.
    /// In this case this is just ParseValue
    /// </summary>
    public override IValueNode ParseResult(object? resultValue) =>
        ParseValue(resultValue);
}

    public sealed class CreditCardNumberType
        : ScalarType
    {
        private readonly ICreditCardValidator _validator;
        /// Like all type system objects, Scalars have support for dependency injection
        public CreditCardNumberType(ICreditCardValidator validator)
            : base("CreditCardNumber")
        {
            _validator = validator;
            Description = "Represents a credit card number in the format of XXXX XXXX XXXX XXXX";
        }
        // define which .NET type represents your type
        public override Type RuntimeType { get; } = typeof(string);
        // define which literals this type can be parsed from.
        public override bool IsInstanceOfType(IValueNode valueSyntax)
        {
            if (valueSyntax == null)
            {
                throw new ArgumentNullException(nameof(valueSyntax));
            }
            return valueSyntax is StringValueNode stringValueNode &&
                _validator.ValidateCreditCard(stringValueNode.Value);
        }
        // define how a literal is parsed to the native .NET type.
        public override object ParseLiteral(IValueNode valueSyntax, bool withDefaults = true)
        {
            if (valueSyntax is StringValueNode stringLiteral &&
                _validator.ValidateCreditCard(stringLiteral.Value))
            {
                return stringLiteral.Value;
            }
            throw new SerializationException(
                "The specified value has to be a credit card number in the format " +
                "XXXX XXXX XXXX XXXX",
                nameof(valueSyntax));
        }
        // define how a native type is parsed into a literal,
        public override IValueNode ParseValue(object? runtimeValue)
        {
            if (runtimeValue is string s &&
                _validator.ValidateCreditCard(s))
            {
                return new StringValueNode(null, s, false);
            }
            throw new SerializationException(
                "The specified value has to be a credit card number in the format " +
                "XXXX XXXX XXXX XXXX");
        }
        public override IValueNode ParseResult(object? resultValue)
        {
            if (resultValue is string s &&
                _validator.ValidateCreditCard(s))
            {
                return new StringValueNode(null, s, false);
            }
            throw new SerializationException(
                "The specified value has to be a credit card number in the format " +
                "XXXX XXXX XXXX XXXX");
        }
        public override bool TrySerialize(object? runtimeValue, out object? resultValue)
        {
            if (runtimeValue is string s &&
                _validator.ValidateCreditCard(s))
            {
                resultValue = s;
                return true;
            }
            resultValue = null;
            return false;
        }
        public override bool TryDeserialize(object? serialized, out object? value)
        {
            if (serialized is string s &&
                _validator.ValidateCreditCard(s))
            {
                value = s;
                return true;
            }
            value = null;
            return false;
        }
    }

dotnet add package HotChocolate.Types.Scalars

public class User 
{
    [GraphQLType(typeof(NonEmptyStringType))]
    public string UserName { get; set; }
}

public class UserType : ObjectType<User> 
{
    protected override void Configure(
        IObjectTypeDescriptor<User> descriptor)
    {
        descriptor.Field(x => x.UserName).Type<NonEmptyStringType>();
    }
}

services
  .AddGraphQLServer()
  // ....
  .AddType<NonEmptyStringType>()