const type = line.getAttribute(this.pfx);
            const delay = line.getAttribute(`${this.pfx}-delay`) || this.lineDelay;

            if (type == 'input') {
                line.setAttribute(`${this.pfx}-cursor`, this.cursor);
                await this.type(line);
                await this._wait(delay);
            }

            else if (type == 'progress') {

/**
 * Validation annotation for URI type constraints.
 * This annotation validates URI strings based on specified protocol types.
 */
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = UriTypeValidator.class)
public @interface UriType {

    /**
     * Specifies the protocol type to validate against.
     *
     * @return the protocol type

  }

  private static String paramString(Class<?> type, int i) {
    return type.getSimpleName() + '@' + i;
  }

  /**
   * Annotates a method to be the instance generator of a certain type. The return type is the
   * generated type. The method parameters correspond to the generated type's type parameters. For

import com.google.errorprone.annotations.DoNotMock;
import java.io.Serializable;
import org.jspecify.annotations.Nullable;

/**
 * An object which can send data from an object of type {@code T} into a {@code PrimitiveSink}.
 * Implementations for common types can be found in {@link Funnels}.
 *
 * <p>Note that serialization of {@linkplain BloomFilter bloom filters} requires the proper

Hug was one of the first frameworks to implement the declaration of API parameter types using Python type hints. This was a great idea that inspired other tools to do the same.

It used custom types in its declarations instead of standard Python types, but it was still a huge step forward.

It also was one of the first frameworks to generate a custom schema declaring the whole API in JSON.

         */
        public int getType() {
            return type;
        }

        /**
         * Sets the notification message type.
         *
         * @param type the message type (WITNESS_RESOURCE_CHANGE, WITNESS_CLIENT_MOVE, WITNESS_SHARE_MOVE, or WITNESS_IP_CHANGE)
         */
        public void setType(int type) {
            this.type = type;
        }

        /**

      ) {
        when {
          isOptional && value == optionalValue -> {
            // Write nothing.
          }

          else -> {
            for ((type, adapter) in choices) {
              if (type.isInstance(value) || (value == null && type == Unit::class)) {
                (adapter as DerAdapter<Any?>).toDer(writer, value)
                return
              }
            }
          }
        }

 */
public interface AuthenticationProvider {

    /**
     * Authentication type enumeration
     */
    enum AuthType {
        NTLM, KERBEROS, SPNEGO, GUEST, ANONYMOUS
    }

    /**
     * Gets the authentication type
     *
     * @return the authentication type
     */
    AuthType getAuthType();

    /**
     * Authenticates using the provided context
     *

```

</div>

/// tip

You can read more about it at <a href="https://12factor.net/config" class="external-link" target="_blank">The Twelve-Factor App: Config</a>.

///

## Types and Validation { #types-and-validation }

 * "https://github.com/google/guava/wiki/FunctionalExplained">the use of functional types</a>.
 *
 * <h3>For Java 8+ users</h3>
 *
 * <p>This interface is now a legacy type. Use {@code java.util.function.Supplier} (or the
 * appropriate primitive specialization such as {@code IntSupplier}) instead whenever possible.
 * Otherwise, at least reduce <i>explicit</i> dependencies on this type by using lambda expressions