resp = new NtTransNotifyChangeResponse(th.getConfig());
            }

            if (log.isTraceEnabled()) {
                log.trace("Sending NtTransNotifyChange for " + this.handle);
            }
            try {
                resp = th.send(req, resp, RequestParam.NO_TIMEOUT, RequestParam.NO_RETRY);
            } catch (final SmbException e) {

For example, to declare a header of `X-Token` that can appear more than once, you can write:

{* ../../docs_src/header_params/tutorial003_an_py310.py hl[9] *}

If you communicate with that *path operation* sending two HTTP headers like:

```
X-Token: foo
X-Token: bar
```

The response would be like:

```JSON
{
    "X-Token values": [
        "bar",
        "foo"
    ]
}
```

# Always check-out / check-in files with LF line endings.
* text=auto eol=lf

hack/verify-flags/known-flags.txt merge=union
test/test_owners.csv merge=union

**/zz_generated.*.go linguist-generated=true
**/types.generated.go linguist-generated=true
**/generated.pb.go linguist-generated=true
**/generated.proto
**/types_swagger_doc_generated.go linguist-generated=true
api/openapi-spec/*.json linguist-generated=true

The process that happens when your API app calls the *external API* is named a "callback". Because the software that the external developer wrote sends a request to your API and then your API *calls back*, sending a request to an *external API* (that was probably created by the same developer).

import jcifs.smb1.dcerpc.msrpc.lsarpc;
import jcifs.smb1.dcerpc.msrpc.netdfs;
import jcifs.smb1.dcerpc.msrpc.samr;
import jcifs.smb1.dcerpc.msrpc.srvsvc;

/**
 * DCERPC binding information for RPC connections.
 * This class manages the binding parameters and interface registry for DCERPC communications.
 */
public class DcerpcBinding {

    private static HashMap INTERFACES;

    static {

    assertThat(toTest).isEqualTo("FooBar{}");
  }

  @GwtIncompatible // Class names are obfuscated in GWT
  public void testToStringHelper_localInnerClass() {
    // Local inner classes have names ending like "Outer.$1Inner"
    class LocalInnerClass {}
    String toTest = MoreObjects.toStringHelper(new LocalInnerClass()).toString();
    assertThat(toTest).isEqualTo("LocalInnerClass{}");
  }

  }

  override fun flushRequest() {
    socket.sink.flush()
  }

  override fun finishRequest() {
    socket.sink.flush()
  }

  /** Returns bytes of a request header for sending on an HTTP transport. */
  fun writeRequest(
    headers: Headers,
    requestLine: String,
  ) {
    check(state == STATE_IDLE) { "state: $state" }
    socket.sink.writeUtf8(requestLine).writeUtf8("\r\n")

Hallo wieder
////

### Headings

Every Markdown heading in the English text (all levels) ends with a part inside curly brackets. This part denotes the hash of this heading, which is used in links to this heading. In translations, translate the heading, but do not translate this hash part, so that links do not break.

Examples of how to translate a heading:

Source (English):

```

import org.codelibs.fess.mylasta.direction.FessConfig;
import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.mail.CardView;
import org.dbflute.mail.send.supplement.SMailPostingDiscloser;

/**
 * Helper class for sending notifications to various platforms.
 */
public class NotificationHelper {

    /**
     * Default constructor.
     */
    public NotificationHelper() {
        // Default constructor
    }

// any for the associated TargetID
type TargetIDResult struct {
	// ID where the remove or send were initiated.
	ID TargetID
	// Stores any error while removing a target or while sending an event.
	Err error
}

// Remove - closes and removes targets by given target IDs.
func (list *TargetList) Remove(targetIDSet TargetIDSet) {
	list.Lock()
	defer list.Unlock()