def TF_WriteRawProtoSummaryOp : TF_Op<"WriteRawProtoSummary", []> {
  let summary = "Writes a `Summary` protocol buffer with serialized string `Summary` protocol buffers.";

  let description = [{
writer: A handle to a summary writer.
step: The step to write the summary for.
tensor: A tensor holding one or more serialized `Summary` protobufs to write.
  }];

  let arguments = (ins

StableHLO function.
### `-tf-xla-call-module-serialization`

_Serializes StableHLO functions from top-level module into `tf.XlaCallModule`'s `module` attribute_

This pass collects StableHLO functions referenced from `tf.XlaCallModule`'s
`_entry_function` attribute into a module, serializes the module into MLIR
bytecode, and embed the bytecode to `tf.XlaCallModule`'s `module` attribute.

}

void VLogGraphIfAsked(const Graph& graph) {
  if (VLOG_IS_ON(3)) {
    GraphDef graph_def;
    graph.ToGraphDef(&graph_def);
    string serialized;
    ::tensorflow::protobuf::TextFormat::PrintToString(graph_def, &serialized);
    LOG(INFO) << serialized;
  }
}

struct InductionVarInfo {
  Output induction_var;
  Output loop_cond;
};

                implementation "org.test:test:1.0"
            }

            // To trigger the issue:
            // 1. serialize a task that uses the transformed artifact
            // 2. serialize a task whose serialization triggers execution of that transform
            // 3. serialize another task that uses the transformed artifact

	// (or any other racing with it), then makes searchAddr positive before continuing, bringing
	// us back to our monotonically decreasing steady-state.
	//
	// A pageAlloc lock serializes updates between min, max, and searchAddr, so abs(searchAddr)
	// is always guaranteed to be >= min and < max (converted to heap addresses).
	//

	// WrapSession is called on the server to produce a session ticket/identity.
	//
	// WrapSession must serialize the session state with [SessionState.Bytes].
	// It may then encrypt the serialized state (for example with
	// [Config.DecryptTicket]) and use it as the ticket, or store the state and
	// return a handle for it.
	//

`org.gradle.plugin.devel.PluginDeclaration` is not serializable anymore.
If you need to serialize it, you can convert it into your own, serializable class.

==== Gradle does not use equals for serialized values in up-to-date checks

Gradle now does not try to use equals when comparing serialized values in up-to-date checks.
For more information see <<equals_up_to_date_deprecation>>.

        },
        "kind": {
          "description": "kind is the serialized kind of the resource. It is normally CamelCase and singular. Custom resource instances will use this value as the `kind` attribute in API calls.",
          "type": "string",
          "default": ""
        },
        "listKind": {
          "description": "listKind is the serialized kind of the list for this resource. Defaults to \"`kind`List\".",

  }

  builder->create<ReturnOp>(ops.front()->getLoc(), results_after_mapping);
  return outlined_func;
}

// Encapsulates `func` in a module and serializes that module.
// `serialized_func_module` is set to the serialized module.
void EncapsulateFuncAndSerialize(FuncOp func,
                                 std::string* serialized_func_module) {
  // Create a new module to hold func and all referenced functions.

}
.inherited-list {
    margin: 10px 0 10px 0;
}
section.class-description {
    line-height: 1.4;
}
.summary section[class$="-summary"], .details section[class$="-details"],
.class-uses .detail, .serialized-class-details {
    padding: 0 20px 5px 10px;
    border: 1px solid var(--border-color);
    background-color: var(--section-background-color);
}
.inherited-list, section[class$="-details"] .detail {