Document the new service builder

codegen-server/src/main/kotlin/software/amazon/smithy/rust/codegen/server/smithy/generators/ServerServiceGeneratorV2.kt

@@ -319,8 +319,68 @@ class ServerServiceGeneratorV2(
     private fun serviceStruct(): Writable = writable {
         documentShape(service, model)
 
+        val functionSignatures =
+            operations.joinToString("\n") { "/// async fn ${builderFieldNames[it]}(input: input::${it.input.get().name}) -> Result<output::${it.output.get().name}, error::${it.id.name}Error> { todo!() }" }
+
         rustTemplate(
             """
+            /// The [`$builderName`] is the place where you can register
+            /// your service $serviceName's operation implementations.
+            ///
+            /// Use [`$builderName`] to construct the
+            /// `$serviceName`. For each of the [operations] modeled in
+            /// your Smithy service, you need to provide an implementation in the
+            /// form of an async function that takes in the
+            /// operation's input as their first parameter, and returns the
+            /// operation's output. If your operation is fallible (i.e. it
+            /// contains the `errors` member in your Smithy model), the function
+            /// implementing the operation has to be fallible (i.e. return a
+            /// [`Result`]). **You must register an implementation for all
+            /// operations with the correct signature**, or your application
+            /// will fail to compile.
+            ///
+            /// [`$serviceName`] can be converted into a type that implements [`tower::make::MakeService`], a _service
+            /// factory_, calling [`$serviceName::into_make_service`]. You can feed this value to a [Hyper server], and the
+            /// server will instantiate and [`serve`] your service.
+            ///
+            /// [`$serviceName::into_make_service_with_connect_info`] converts $serviceName into [`tower::make::MakeService`]
+            /// with [`ConnectInfo`](#{SmithyHttpServer}::request::connect_info::ConnectInfo).
+            /// You can write your implementations to be passed in the connection information, populated by the [Hyper server].
+            ///
+            /// Here's a full example to get you started:
+            ///
+            /// ```rust
+            /// use std::net::SocketAddr;
+            /// use pokemon_service_server_sdk::{input, output, error};
+            ///
+            /// ##[tokio::main]
+            /// pub async fn main() {
+            ///    let app = $serviceName::builder_without_plugins()
+            ${builderFieldNames.values.joinToString("\n") { "///        .$it($it)" }}
+            ///        .build()
+            ///        .expect("failed to build an instance of $serviceName");
+            ///
+            ///    let bind: SocketAddr = format!("{}:{}", "127.0.0.1", "6969")
+            ///        .parse()
+            ///        .expect("unable to parse the server bind address and port");
+            ///
+            ///    let server = hyper::Server::bind(&bind).serve(app.into_make_service());
+            ///
+            ///    // Run your service!
+            ///    // if let Err(err) = server.await {
+            ///    //   eprintln!("server error: {}", err);
+            ///    // }
+            /// }
+            ///
+            $functionSignatures
+            ///
+            /// ```
+            ///
+            /// [`serve`]: https://docs.rs/hyper/0.14.16/hyper/server/struct.Builder.html##method.serve
+            /// [`tower::make::MakeService`]: https://docs.rs/tower/latest/tower/make/trait.MakeService.html
+            /// [HTTP binding traits]: https://awslabs.github.io/smithy/1.0/spec/core/http-traits.html
+            /// [operations]: https://awslabs.github.io/smithy/1.0/spec/core/model.html##operation
+            /// [Hyper server]: https://docs.rs/hyper/latest/hyper/server/index.html
             ##[derive(Clone)]
             pub struct $serviceName<S = #{SmithyHttpServer}::routing::Route> {
                 router: #{SmithyHttpServer}::routers::RoutingService<#{Router}<S>, #{Protocol}>,