package loggertypes

// TargetType indicates type of the target e.g. console, http, kafka
type TargetType uint8

//go:generate stringer -type=TargetType -trimprefix=Target $GOFILE

// Constants for target types
const (
	_ TargetType = iota
	TargetConsole
	TargetHTTP
	TargetKafka
)

// TargetStats contains statistics for a target.
type TargetStats struct {

#### Types génériques

Les types qui peuvent contenir des paramètres de types entre crochets, comme :

* `List`
* `Tuple`
* `Set`
* `Dict`
* `Optional`
* ...et d'autres.

sont appelés des **types génériques** ou **Generics**.

### Classes en tant que types

Vous pouvez aussi déclarer une classe comme type d'une variable.

	return bytes, json.Unmarshal(val, j.val)
}

// Msgsize returns the size of an empty JSON object.
func (j *JSON[T]) Msgsize() int {
	return j.p.emptySz
}

// NoPayload is a type that can be used for handlers that do not use a payload.
type NoPayload struct{}

// Msgsize returns 0.
func (p NoPayload) Msgsize() int {
	return 0
}

// UnmarshalMsg satisfies the interface, but is a no-op.

// Error implements Error interface
func (b BatchJobYamlErr) Error() string {
	return fmt.Sprintf("%s\n Hint: error near line: %d, col: %d", b.msg, b.line, b.col)
}

// BatchJobKV is a key-value data type which supports wildcard matching
type BatchJobKV struct {
	line, col int
	Key       string `yaml:"key" json:"key"`
	Value     string `yaml:"value" json:"value"`
}

var _ yaml.Unmarshaler = &BatchJobKV{}

        when:
        def link = renderer.link(type('some.other.Class', true), listener)

        then:
        format(link) == '<classname><classname>some.other.Class</classname>[]</classname>'
    }

    def rendersLinkToParameterizedType() {
        def metaData = type('org.gradle.SomeClass')
        metaData.addTypeArg(type('Type1'))
        metaData.addTypeArg(type('Type2'))

        when:

    }

    /**
     * Sets the MIC
     *
     * @param type1 the Type-1 message bytes
     * @param type2 the Type-2 message bytes
     * @throws GeneralSecurityException if a cryptographic error occurs
     * @throws IOException if an I/O error occurs
     */
    public void setupMIC(final byte[] type1, final byte[] type2) throws GeneralSecurityException, IOException {
        final byte[] sk = this.masterKey;

}

type metricValue struct {
	Labels map[string]string
	Value  float64
}

// MetricValues - type to set metric values retrieved while loading metrics. A
// value of this type is passed to the `MetricsLoaderFn`.
type MetricValues struct {
	values      map[MetricName][]metricValue
	descriptors map[MetricName]MetricDescriptor
}

func newMetricValues(d map[MetricName]MetricDescriptor) MetricValues {

 * <p>
 * Example usage:
 * <pre>
 * {@literal @}Typed(ServiceImpl.class)
 * public class ServiceImpl implements Service {
 *     // Implementation
 * }
 * </pre>
 *
 * @since 4.0.0
 */
@Target({FIELD, METHOD, TYPE})
@Retention(RUNTIME)
@Documented
public @interface Typed {
    /**
     * Specifies the types that should be considered for dependency injection.
     * <p>

    // Packet Types (ptype)
    /**
     * Request packet type
     */
    int RPC_PT_REQUEST = 0x00;
    /**
     * Ping packet type
     */
    int RPC_PT_PING = 0x01;
    /**
     * Response packet type
     */
    int RPC_PT_RESPONSE = 0x02;
    /**
     * Fault packet type - indicates an error
     */
    int RPC_PT_FAULT = 0x03;
    /**

    /**
     * Creates a Type-3 message in response to the given Type-2 message.
     *
     * @param type2 the Type-2 message to respond to
     * @param password the user's password
     * @param domain the domain name
     * @param user the username
     * @param workstation the workstation name
     * @param flags the flags to use for the Type-3 message
     */