rivet_identity/
input.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2use std::fmt::Write;
3/// See [`CancelGameLinkInput`](crate::input::CancelGameLinkInput)
4pub mod cancel_game_link_input {
5	/// A builder for [`CancelGameLinkInput`](crate::input::CancelGameLinkInput)
6	#[non_exhaustive]
7	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
8	pub struct Builder {
9		pub(crate) identity_link_token: std::option::Option<std::string::String>,
10	}
11	impl Builder {
12		/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
13		pub fn identity_link_token(mut self, input: impl Into<std::string::String>) -> Self {
14			self.identity_link_token = Some(input.into());
15			self
16		}
17		/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
18		pub fn set_identity_link_token(
19			mut self,
20			input: std::option::Option<std::string::String>,
21		) -> Self {
22			self.identity_link_token = input;
23			self
24		}
25		/// Consumes the builder and constructs a [`CancelGameLinkInput`](crate::input::CancelGameLinkInput)
26		pub fn build(
27			self,
28		) -> std::result::Result<
29			crate::input::CancelGameLinkInput,
30			aws_smithy_http::operation::BuildError,
31		> {
32			Ok(crate::input::CancelGameLinkInput {
33				identity_link_token: self.identity_link_token,
34			})
35		}
36	}
37}
38#[doc(hidden)]
39pub type CancelGameLinkInputOperationOutputAlias = crate::operation::CancelGameLink;
40#[doc(hidden)]
41pub type CancelGameLinkInputOperationRetryAlias = ();
42impl CancelGameLinkInput {
43	/// Consumes the builder and constructs an Operation<[`CancelGameLink`](crate::operation::CancelGameLink)>
44	#[allow(unused_mut)]
45	#[allow(clippy::let_and_return)]
46	#[allow(clippy::needless_borrow)]
47	pub async fn make_operation(
48		&self,
49		_config: &crate::config::Config,
50	) -> std::result::Result<
51		aws_smithy_http::operation::Operation<crate::operation::CancelGameLink, ()>,
52		aws_smithy_http::operation::BuildError,
53	> {
54		let mut request = {
55			fn uri_base(
56				_input: &crate::input::CancelGameLinkInput,
57				output: &mut String,
58			) -> Result<(), aws_smithy_http::operation::BuildError> {
59				write!(output, "/game-links/cancel").expect("formatting should succeed");
60				Ok(())
61			}
62			#[allow(clippy::unnecessary_wraps)]
63			fn update_http_builder(
64				input: &crate::input::CancelGameLinkInput,
65				_config: &crate::config::Config,
66				builder: http::request::Builder,
67			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
68			{
69				let mut _uri = String::new();
70				_uri = format!("{}{}", _config.uri.clone(), _uri);
71				uri_base(input, &mut _uri)?;
72				Ok(builder.method("POST").uri(_uri))
73			}
74			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
75			let mut builder = if let Some(auth) = &_config.auth {
76				builder.header(http::header::AUTHORIZATION, auth.clone())
77			} else {
78				builder
79			};
80			builder = aws_smithy_http::header::set_request_header_if_absent(
81				builder,
82				http::header::CONTENT_TYPE,
83				"application/json",
84			);
85			builder
86		};
87		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
88		#[allow(clippy::useless_conversion)]
89		let body = aws_smithy_http::body::SdkBody::from(
90			crate::operation_ser::serialize_operation_crate_operation_cancel_game_link(&self)?,
91		);
92		if let Some(content_length) = body.content_length() {
93			request = aws_smithy_http::header::set_request_header_if_absent(
94				request,
95				http::header::CONTENT_LENGTH,
96				content_length,
97			);
98		}
99		let request = request.body(body).expect("should be valid request");
100		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
101		request
102			.properties_mut()
103			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
104		let op = aws_smithy_http::operation::Operation::new(
105			request,
106			crate::operation::CancelGameLink::new(),
107		)
108		.with_metadata(aws_smithy_http::operation::Metadata::new(
109			"CancelGameLink",
110			"IdentityService",
111		));
112		Ok(op)
113	}
114	/// Creates a new builder-style object to manufacture [`CancelGameLinkInput`](crate::input::CancelGameLinkInput)
115	pub fn builder() -> crate::input::cancel_game_link_input::Builder {
116		crate::input::cancel_game_link_input::Builder::default()
117	}
118}
119
120/// See [`CompleteGameLinkInput`](crate::input::CompleteGameLinkInput)
121pub mod complete_game_link_input {
122	/// A builder for [`CompleteGameLinkInput`](crate::input::CompleteGameLinkInput)
123	#[non_exhaustive]
124	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
125	pub struct Builder {
126		pub(crate) identity_link_token: std::option::Option<std::string::String>,
127	}
128	impl Builder {
129		/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
130		pub fn identity_link_token(mut self, input: impl Into<std::string::String>) -> Self {
131			self.identity_link_token = Some(input.into());
132			self
133		}
134		/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
135		pub fn set_identity_link_token(
136			mut self,
137			input: std::option::Option<std::string::String>,
138		) -> Self {
139			self.identity_link_token = input;
140			self
141		}
142		/// Consumes the builder and constructs a [`CompleteGameLinkInput`](crate::input::CompleteGameLinkInput)
143		pub fn build(
144			self,
145		) -> std::result::Result<
146			crate::input::CompleteGameLinkInput,
147			aws_smithy_http::operation::BuildError,
148		> {
149			Ok(crate::input::CompleteGameLinkInput {
150				identity_link_token: self.identity_link_token,
151			})
152		}
153	}
154}
155#[doc(hidden)]
156pub type CompleteGameLinkInputOperationOutputAlias = crate::operation::CompleteGameLink;
157#[doc(hidden)]
158pub type CompleteGameLinkInputOperationRetryAlias = ();
159impl CompleteGameLinkInput {
160	/// Consumes the builder and constructs an Operation<[`CompleteGameLink`](crate::operation::CompleteGameLink)>
161	#[allow(unused_mut)]
162	#[allow(clippy::let_and_return)]
163	#[allow(clippy::needless_borrow)]
164	pub async fn make_operation(
165		&self,
166		_config: &crate::config::Config,
167	) -> std::result::Result<
168		aws_smithy_http::operation::Operation<crate::operation::CompleteGameLink, ()>,
169		aws_smithy_http::operation::BuildError,
170	> {
171		let mut request = {
172			fn uri_base(
173				_input: &crate::input::CompleteGameLinkInput,
174				output: &mut String,
175			) -> Result<(), aws_smithy_http::operation::BuildError> {
176				write!(output, "/game-links/complete").expect("formatting should succeed");
177				Ok(())
178			}
179			#[allow(clippy::unnecessary_wraps)]
180			fn update_http_builder(
181				input: &crate::input::CompleteGameLinkInput,
182				_config: &crate::config::Config,
183				builder: http::request::Builder,
184			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
185			{
186				let mut _uri = String::new();
187				_uri = format!("{}{}", _config.uri.clone(), _uri);
188				uri_base(input, &mut _uri)?;
189				Ok(builder.method("POST").uri(_uri))
190			}
191			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
192			let mut builder = if let Some(auth) = &_config.auth {
193				builder.header(http::header::AUTHORIZATION, auth.clone())
194			} else {
195				builder
196			};
197			builder = aws_smithy_http::header::set_request_header_if_absent(
198				builder,
199				http::header::CONTENT_TYPE,
200				"application/json",
201			);
202			builder
203		};
204		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
205		#[allow(clippy::useless_conversion)]
206		let body = aws_smithy_http::body::SdkBody::from(
207			crate::operation_ser::serialize_operation_crate_operation_complete_game_link(&self)?,
208		);
209		if let Some(content_length) = body.content_length() {
210			request = aws_smithy_http::header::set_request_header_if_absent(
211				request,
212				http::header::CONTENT_LENGTH,
213				content_length,
214			);
215		}
216		let request = request.body(body).expect("should be valid request");
217		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
218		request
219			.properties_mut()
220			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
221		let op = aws_smithy_http::operation::Operation::new(
222			request,
223			crate::operation::CompleteGameLink::new(),
224		)
225		.with_metadata(aws_smithy_http::operation::Metadata::new(
226			"CompleteGameLink",
227			"IdentityService",
228		));
229		Ok(op)
230	}
231	/// Creates a new builder-style object to manufacture [`CompleteGameLinkInput`](crate::input::CompleteGameLinkInput)
232	pub fn builder() -> crate::input::complete_game_link_input::Builder {
233		crate::input::complete_game_link_input::Builder::default()
234	}
235}
236
237/// See [`CompleteIdentityAvatarUploadInput`](crate::input::CompleteIdentityAvatarUploadInput)
238pub mod complete_identity_avatar_upload_input {
239	/// A builder for [`CompleteIdentityAvatarUploadInput`](crate::input::CompleteIdentityAvatarUploadInput)
240	#[non_exhaustive]
241	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
242	pub struct Builder {
243		pub(crate) upload_id: std::option::Option<std::string::String>,
244	}
245	impl Builder {
246		/// A universally unique identifier.
247		pub fn upload_id(mut self, input: impl Into<std::string::String>) -> Self {
248			self.upload_id = Some(input.into());
249			self
250		}
251		/// A universally unique identifier.
252		pub fn set_upload_id(mut self, input: std::option::Option<std::string::String>) -> Self {
253			self.upload_id = input;
254			self
255		}
256		/// Consumes the builder and constructs a [`CompleteIdentityAvatarUploadInput`](crate::input::CompleteIdentityAvatarUploadInput)
257		pub fn build(
258			self,
259		) -> std::result::Result<
260			crate::input::CompleteIdentityAvatarUploadInput,
261			aws_smithy_http::operation::BuildError,
262		> {
263			Ok(crate::input::CompleteIdentityAvatarUploadInput {
264				upload_id: self.upload_id,
265			})
266		}
267	}
268}
269#[doc(hidden)]
270pub type CompleteIdentityAvatarUploadInputOperationOutputAlias =
271	crate::operation::CompleteIdentityAvatarUpload;
272#[doc(hidden)]
273pub type CompleteIdentityAvatarUploadInputOperationRetryAlias = ();
274impl CompleteIdentityAvatarUploadInput {
275	/// Consumes the builder and constructs an Operation<[`CompleteIdentityAvatarUpload`](crate::operation::CompleteIdentityAvatarUpload)>
276	#[allow(unused_mut)]
277	#[allow(clippy::let_and_return)]
278	#[allow(clippy::needless_borrow)]
279	pub async fn make_operation(
280		&self,
281		_config: &crate::config::Config,
282	) -> std::result::Result<
283		aws_smithy_http::operation::Operation<crate::operation::CompleteIdentityAvatarUpload, ()>,
284		aws_smithy_http::operation::BuildError,
285	> {
286		let mut request = {
287			fn uri_base(
288				_input: &crate::input::CompleteIdentityAvatarUploadInput,
289				output: &mut String,
290			) -> Result<(), aws_smithy_http::operation::BuildError> {
291				let input_1 = &_input.upload_id;
292				let input_1 = input_1.as_ref().ok_or(
293					aws_smithy_http::operation::BuildError::MissingField {
294						field: "upload_id",
295						details: "cannot be empty or unset",
296					},
297				)?;
298				let upload_id = aws_smithy_http::label::fmt_string(input_1, false);
299				if upload_id.is_empty() {
300					return Err(aws_smithy_http::operation::BuildError::MissingField {
301						field: "upload_id",
302						details: "cannot be empty or unset",
303					});
304				}
305				write!(
306					output,
307					"/identities/avatar-upload/{upload_id}/complete",
308					upload_id = upload_id
309				)
310				.expect("formatting should succeed");
311				Ok(())
312			}
313			#[allow(clippy::unnecessary_wraps)]
314			fn update_http_builder(
315				input: &crate::input::CompleteIdentityAvatarUploadInput,
316				_config: &crate::config::Config,
317				builder: http::request::Builder,
318			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
319			{
320				let mut _uri = String::new();
321				_uri = format!("{}{}", _config.uri.clone(), _uri);
322				uri_base(input, &mut _uri)?;
323				Ok(builder.method("POST").uri(_uri))
324			}
325			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
326			let mut builder = if let Some(auth) = &_config.auth {
327				builder.header(http::header::AUTHORIZATION, auth.clone())
328			} else {
329				builder
330			};
331			builder
332		};
333		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
334		#[allow(clippy::useless_conversion)]
335		let body = aws_smithy_http::body::SdkBody::from("{}");
336		let request = request.body(body).expect("should be valid request");
337		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
338		request
339			.properties_mut()
340			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
341		let op = aws_smithy_http::operation::Operation::new(
342			request,
343			crate::operation::CompleteIdentityAvatarUpload::new(),
344		)
345		.with_metadata(aws_smithy_http::operation::Metadata::new(
346			"CompleteIdentityAvatarUpload",
347			"IdentityService",
348		));
349		Ok(op)
350	}
351	/// Creates a new builder-style object to manufacture [`CompleteIdentityAvatarUploadInput`](crate::input::CompleteIdentityAvatarUploadInput)
352	pub fn builder() -> crate::input::complete_identity_avatar_upload_input::Builder {
353		crate::input::complete_identity_avatar_upload_input::Builder::default()
354	}
355}
356
357/// See [`FollowIdentityInput`](crate::input::FollowIdentityInput)
358pub mod follow_identity_input {
359	/// A builder for [`FollowIdentityInput`](crate::input::FollowIdentityInput)
360	#[non_exhaustive]
361	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
362	pub struct Builder {
363		pub(crate) identity_id: std::option::Option<std::string::String>,
364	}
365	impl Builder {
366		/// A universally unique identifier.
367		pub fn identity_id(mut self, input: impl Into<std::string::String>) -> Self {
368			self.identity_id = Some(input.into());
369			self
370		}
371		/// A universally unique identifier.
372		pub fn set_identity_id(mut self, input: std::option::Option<std::string::String>) -> Self {
373			self.identity_id = input;
374			self
375		}
376		/// Consumes the builder and constructs a [`FollowIdentityInput`](crate::input::FollowIdentityInput)
377		pub fn build(
378			self,
379		) -> std::result::Result<
380			crate::input::FollowIdentityInput,
381			aws_smithy_http::operation::BuildError,
382		> {
383			Ok(crate::input::FollowIdentityInput {
384				identity_id: self.identity_id,
385			})
386		}
387	}
388}
389#[doc(hidden)]
390pub type FollowIdentityInputOperationOutputAlias = crate::operation::FollowIdentity;
391#[doc(hidden)]
392pub type FollowIdentityInputOperationRetryAlias = ();
393impl FollowIdentityInput {
394	/// Consumes the builder and constructs an Operation<[`FollowIdentity`](crate::operation::FollowIdentity)>
395	#[allow(unused_mut)]
396	#[allow(clippy::let_and_return)]
397	#[allow(clippy::needless_borrow)]
398	pub async fn make_operation(
399		&self,
400		_config: &crate::config::Config,
401	) -> std::result::Result<
402		aws_smithy_http::operation::Operation<crate::operation::FollowIdentity, ()>,
403		aws_smithy_http::operation::BuildError,
404	> {
405		let mut request = {
406			fn uri_base(
407				_input: &crate::input::FollowIdentityInput,
408				output: &mut String,
409			) -> Result<(), aws_smithy_http::operation::BuildError> {
410				let input_2 = &_input.identity_id;
411				let input_2 = input_2.as_ref().ok_or(
412					aws_smithy_http::operation::BuildError::MissingField {
413						field: "identity_id",
414						details: "cannot be empty or unset",
415					},
416				)?;
417				let identity_id = aws_smithy_http::label::fmt_string(input_2, false);
418				if identity_id.is_empty() {
419					return Err(aws_smithy_http::operation::BuildError::MissingField {
420						field: "identity_id",
421						details: "cannot be empty or unset",
422					});
423				}
424				write!(
425					output,
426					"/identities/{identity_id}/follow",
427					identity_id = identity_id
428				)
429				.expect("formatting should succeed");
430				Ok(())
431			}
432			#[allow(clippy::unnecessary_wraps)]
433			fn update_http_builder(
434				input: &crate::input::FollowIdentityInput,
435				_config: &crate::config::Config,
436				builder: http::request::Builder,
437			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
438			{
439				let mut _uri = String::new();
440				_uri = format!("{}{}", _config.uri.clone(), _uri);
441				uri_base(input, &mut _uri)?;
442				Ok(builder.method("POST").uri(_uri))
443			}
444			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
445			let mut builder = if let Some(auth) = &_config.auth {
446				builder.header(http::header::AUTHORIZATION, auth.clone())
447			} else {
448				builder
449			};
450			builder
451		};
452		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
453		#[allow(clippy::useless_conversion)]
454		let body = aws_smithy_http::body::SdkBody::from("{}");
455		let request = request.body(body).expect("should be valid request");
456		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
457		request
458			.properties_mut()
459			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
460		let op = aws_smithy_http::operation::Operation::new(
461			request,
462			crate::operation::FollowIdentity::new(),
463		)
464		.with_metadata(aws_smithy_http::operation::Metadata::new(
465			"FollowIdentity",
466			"IdentityService",
467		));
468		Ok(op)
469	}
470	/// Creates a new builder-style object to manufacture [`FollowIdentityInput`](crate::input::FollowIdentityInput)
471	pub fn builder() -> crate::input::follow_identity_input::Builder {
472		crate::input::follow_identity_input::Builder::default()
473	}
474}
475
476/// See [`GetGameLinkInput`](crate::input::GetGameLinkInput)
477pub mod get_game_link_input {
478	/// A builder for [`GetGameLinkInput`](crate::input::GetGameLinkInput)
479	#[non_exhaustive]
480	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
481	pub struct Builder {
482		pub(crate) identity_link_token: std::option::Option<std::string::String>,
483		pub(crate) watch_index: std::option::Option<std::string::String>,
484	}
485	impl Builder {
486		/// `identity_link_token` returned by `PrepareGameLink`.
487		pub fn identity_link_token(mut self, input: impl Into<std::string::String>) -> Self {
488			self.identity_link_token = Some(input.into());
489			self
490		}
491		/// `identity_link_token` returned by `PrepareGameLink`.
492		pub fn set_identity_link_token(
493			mut self,
494			input: std::option::Option<std::string::String>,
495		) -> Self {
496			self.identity_link_token = input;
497			self
498		}
499		/// A query parameter denoting the requests watch index.
500		pub fn watch_index(mut self, input: impl Into<std::string::String>) -> Self {
501			self.watch_index = Some(input.into());
502			self
503		}
504		/// A query parameter denoting the requests watch index.
505		pub fn set_watch_index(mut self, input: std::option::Option<std::string::String>) -> Self {
506			self.watch_index = input;
507			self
508		}
509		/// Consumes the builder and constructs a [`GetGameLinkInput`](crate::input::GetGameLinkInput)
510		pub fn build(
511			self,
512		) -> std::result::Result<
513			crate::input::GetGameLinkInput,
514			aws_smithy_http::operation::BuildError,
515		> {
516			Ok(crate::input::GetGameLinkInput {
517				identity_link_token: self.identity_link_token,
518				watch_index: self.watch_index,
519			})
520		}
521	}
522}
523#[doc(hidden)]
524pub type GetGameLinkInputOperationOutputAlias = crate::operation::GetGameLink;
525#[doc(hidden)]
526pub type GetGameLinkInputOperationRetryAlias = ();
527impl GetGameLinkInput {
528	/// Consumes the builder and constructs an Operation<[`GetGameLink`](crate::operation::GetGameLink)>
529	#[allow(unused_mut)]
530	#[allow(clippy::let_and_return)]
531	#[allow(clippy::needless_borrow)]
532	pub async fn make_operation(
533		&self,
534		_config: &crate::config::Config,
535	) -> std::result::Result<
536		aws_smithy_http::operation::Operation<crate::operation::GetGameLink, ()>,
537		aws_smithy_http::operation::BuildError,
538	> {
539		let mut request = {
540			fn uri_base(
541				_input: &crate::input::GetGameLinkInput,
542				output: &mut String,
543			) -> Result<(), aws_smithy_http::operation::BuildError> {
544				write!(output, "/game-links").expect("formatting should succeed");
545				Ok(())
546			}
547			fn uri_query(
548				_input: &crate::input::GetGameLinkInput,
549				mut output: &mut String,
550			) -> Result<(), aws_smithy_http::operation::BuildError> {
551				let mut query = aws_smithy_http::query::Writer::new(&mut output);
552				if let Some(inner_3) = &_input.identity_link_token {
553					query.push_kv(
554						"identity_link_token",
555						&aws_smithy_http::query::fmt_string(&inner_3),
556					);
557				}
558				if let Some(inner_4) = &_input.watch_index {
559					query.push_kv("watch_index", &aws_smithy_http::query::fmt_string(&inner_4));
560				}
561				Ok(())
562			}
563			#[allow(clippy::unnecessary_wraps)]
564			fn update_http_builder(
565				input: &crate::input::GetGameLinkInput,
566				_config: &crate::config::Config,
567				builder: http::request::Builder,
568			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
569			{
570				let mut _uri = String::new();
571				_uri = format!("{}{}", _config.uri.clone(), _uri);
572				uri_base(input, &mut _uri)?;
573				uri_query(input, &mut _uri)?;
574				Ok(builder.method("GET").uri(_uri))
575			}
576			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
577			let mut builder = if let Some(auth) = &_config.auth {
578				builder.header(http::header::AUTHORIZATION, auth.clone())
579			} else {
580				builder
581			};
582			builder
583		};
584		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
585		#[allow(clippy::useless_conversion)]
586		let body = aws_smithy_http::body::SdkBody::from("");
587		let request = request.body(body).expect("should be valid request");
588		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
589		request
590			.properties_mut()
591			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
592		let op = aws_smithy_http::operation::Operation::new(
593			request,
594			crate::operation::GetGameLink::new(),
595		)
596		.with_metadata(aws_smithy_http::operation::Metadata::new(
597			"GetGameLink",
598			"IdentityService",
599		));
600		Ok(op)
601	}
602	/// Creates a new builder-style object to manufacture [`GetGameLinkInput`](crate::input::GetGameLinkInput)
603	pub fn builder() -> crate::input::get_game_link_input::Builder {
604		crate::input::get_game_link_input::Builder::default()
605	}
606}
607
608/// See [`GetIdentityHandlesInput`](crate::input::GetIdentityHandlesInput)
609pub mod get_identity_handles_input {
610	/// A builder for [`GetIdentityHandlesInput`](crate::input::GetIdentityHandlesInput)
611	#[non_exhaustive]
612	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
613	pub struct Builder {
614		pub(crate) identity_ids: std::option::Option<std::vec::Vec<std::string::String>>,
615	}
616	impl Builder {
617		/// Appends an item to `identity_ids`.
618		///
619		/// To override the contents of this collection use [`set_identity_ids`](Self::set_identity_ids).
620		///
621		/// A list of identity IDs.
622		pub fn identity_ids(mut self, input: impl Into<std::string::String>) -> Self {
623			let mut v = self.identity_ids.unwrap_or_default();
624			v.push(input.into());
625			self.identity_ids = Some(v);
626			self
627		}
628		/// A list of identity IDs.
629		pub fn set_identity_ids(
630			mut self,
631			input: std::option::Option<std::vec::Vec<std::string::String>>,
632		) -> Self {
633			self.identity_ids = input;
634			self
635		}
636		/// Consumes the builder and constructs a [`GetIdentityHandlesInput`](crate::input::GetIdentityHandlesInput)
637		pub fn build(
638			self,
639		) -> std::result::Result<
640			crate::input::GetIdentityHandlesInput,
641			aws_smithy_http::operation::BuildError,
642		> {
643			Ok(crate::input::GetIdentityHandlesInput {
644				identity_ids: self.identity_ids,
645			})
646		}
647	}
648}
649#[doc(hidden)]
650pub type GetIdentityHandlesInputOperationOutputAlias = crate::operation::GetIdentityHandles;
651#[doc(hidden)]
652pub type GetIdentityHandlesInputOperationRetryAlias = ();
653impl GetIdentityHandlesInput {
654	/// Consumes the builder and constructs an Operation<[`GetIdentityHandles`](crate::operation::GetIdentityHandles)>
655	#[allow(unused_mut)]
656	#[allow(clippy::let_and_return)]
657	#[allow(clippy::needless_borrow)]
658	pub async fn make_operation(
659		&self,
660		_config: &crate::config::Config,
661	) -> std::result::Result<
662		aws_smithy_http::operation::Operation<crate::operation::GetIdentityHandles, ()>,
663		aws_smithy_http::operation::BuildError,
664	> {
665		let mut request = {
666			fn uri_base(
667				_input: &crate::input::GetIdentityHandlesInput,
668				output: &mut String,
669			) -> Result<(), aws_smithy_http::operation::BuildError> {
670				write!(output, "/identities/batch/handle").expect("formatting should succeed");
671				Ok(())
672			}
673			fn uri_query(
674				_input: &crate::input::GetIdentityHandlesInput,
675				mut output: &mut String,
676			) -> Result<(), aws_smithy_http::operation::BuildError> {
677				let mut query = aws_smithy_http::query::Writer::new(&mut output);
678				if let Some(inner_5) = &_input.identity_ids {
679					for inner_6 in inner_5 {
680						query.push_kv(
681							"identity_ids",
682							&aws_smithy_http::query::fmt_string(&inner_6),
683						);
684					}
685				}
686				Ok(())
687			}
688			#[allow(clippy::unnecessary_wraps)]
689			fn update_http_builder(
690				input: &crate::input::GetIdentityHandlesInput,
691				_config: &crate::config::Config,
692				builder: http::request::Builder,
693			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
694			{
695				let mut _uri = String::new();
696				_uri = format!("{}{}", _config.uri.clone(), _uri);
697				uri_base(input, &mut _uri)?;
698				uri_query(input, &mut _uri)?;
699				Ok(builder.method("GET").uri(_uri))
700			}
701			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
702			let mut builder = if let Some(auth) = &_config.auth {
703				builder.header(http::header::AUTHORIZATION, auth.clone())
704			} else {
705				builder
706			};
707			builder
708		};
709		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
710		#[allow(clippy::useless_conversion)]
711		let body = aws_smithy_http::body::SdkBody::from("");
712		let request = request.body(body).expect("should be valid request");
713		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
714		request
715			.properties_mut()
716			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
717		let op = aws_smithy_http::operation::Operation::new(
718			request,
719			crate::operation::GetIdentityHandles::new(),
720		)
721		.with_metadata(aws_smithy_http::operation::Metadata::new(
722			"GetIdentityHandles",
723			"IdentityService",
724		));
725		Ok(op)
726	}
727	/// Creates a new builder-style object to manufacture [`GetIdentityHandlesInput`](crate::input::GetIdentityHandlesInput)
728	pub fn builder() -> crate::input::get_identity_handles_input::Builder {
729		crate::input::get_identity_handles_input::Builder::default()
730	}
731}
732
733/// See [`GetIdentityProfileInput`](crate::input::GetIdentityProfileInput)
734pub mod get_identity_profile_input {
735	/// A builder for [`GetIdentityProfileInput`](crate::input::GetIdentityProfileInput)
736	#[non_exhaustive]
737	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
738	pub struct Builder {
739		pub(crate) identity_id: std::option::Option<std::string::String>,
740		pub(crate) watch_index: std::option::Option<std::string::String>,
741	}
742	impl Builder {
743		/// A universally unique identifier.
744		pub fn identity_id(mut self, input: impl Into<std::string::String>) -> Self {
745			self.identity_id = Some(input.into());
746			self
747		}
748		/// A universally unique identifier.
749		pub fn set_identity_id(mut self, input: std::option::Option<std::string::String>) -> Self {
750			self.identity_id = input;
751			self
752		}
753		/// A query parameter denoting the requests watch index.
754		pub fn watch_index(mut self, input: impl Into<std::string::String>) -> Self {
755			self.watch_index = Some(input.into());
756			self
757		}
758		/// A query parameter denoting the requests watch index.
759		pub fn set_watch_index(mut self, input: std::option::Option<std::string::String>) -> Self {
760			self.watch_index = input;
761			self
762		}
763		/// Consumes the builder and constructs a [`GetIdentityProfileInput`](crate::input::GetIdentityProfileInput)
764		pub fn build(
765			self,
766		) -> std::result::Result<
767			crate::input::GetIdentityProfileInput,
768			aws_smithy_http::operation::BuildError,
769		> {
770			Ok(crate::input::GetIdentityProfileInput {
771				identity_id: self.identity_id,
772				watch_index: self.watch_index,
773			})
774		}
775	}
776}
777#[doc(hidden)]
778pub type GetIdentityProfileInputOperationOutputAlias = crate::operation::GetIdentityProfile;
779#[doc(hidden)]
780pub type GetIdentityProfileInputOperationRetryAlias = ();
781impl GetIdentityProfileInput {
782	/// Consumes the builder and constructs an Operation<[`GetIdentityProfile`](crate::operation::GetIdentityProfile)>
783	#[allow(unused_mut)]
784	#[allow(clippy::let_and_return)]
785	#[allow(clippy::needless_borrow)]
786	pub async fn make_operation(
787		&self,
788		_config: &crate::config::Config,
789	) -> std::result::Result<
790		aws_smithy_http::operation::Operation<crate::operation::GetIdentityProfile, ()>,
791		aws_smithy_http::operation::BuildError,
792	> {
793		let mut request = {
794			fn uri_base(
795				_input: &crate::input::GetIdentityProfileInput,
796				output: &mut String,
797			) -> Result<(), aws_smithy_http::operation::BuildError> {
798				let input_7 = &_input.identity_id;
799				let input_7 = input_7.as_ref().ok_or(
800					aws_smithy_http::operation::BuildError::MissingField {
801						field: "identity_id",
802						details: "cannot be empty or unset",
803					},
804				)?;
805				let identity_id = aws_smithy_http::label::fmt_string(input_7, false);
806				if identity_id.is_empty() {
807					return Err(aws_smithy_http::operation::BuildError::MissingField {
808						field: "identity_id",
809						details: "cannot be empty or unset",
810					});
811				}
812				write!(
813					output,
814					"/identities/{identity_id}/profile",
815					identity_id = identity_id
816				)
817				.expect("formatting should succeed");
818				Ok(())
819			}
820			fn uri_query(
821				_input: &crate::input::GetIdentityProfileInput,
822				mut output: &mut String,
823			) -> Result<(), aws_smithy_http::operation::BuildError> {
824				let mut query = aws_smithy_http::query::Writer::new(&mut output);
825				if let Some(inner_8) = &_input.watch_index {
826					query.push_kv("watch_index", &aws_smithy_http::query::fmt_string(&inner_8));
827				}
828				Ok(())
829			}
830			#[allow(clippy::unnecessary_wraps)]
831			fn update_http_builder(
832				input: &crate::input::GetIdentityProfileInput,
833				_config: &crate::config::Config,
834				builder: http::request::Builder,
835			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
836			{
837				let mut _uri = String::new();
838				_uri = format!("{}{}", _config.uri.clone(), _uri);
839				uri_base(input, &mut _uri)?;
840				uri_query(input, &mut _uri)?;
841				Ok(builder.method("GET").uri(_uri))
842			}
843			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
844			let mut builder = if let Some(auth) = &_config.auth {
845				builder.header(http::header::AUTHORIZATION, auth.clone())
846			} else {
847				builder
848			};
849			builder
850		};
851		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
852		#[allow(clippy::useless_conversion)]
853		let body = aws_smithy_http::body::SdkBody::from("");
854		let request = request.body(body).expect("should be valid request");
855		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
856		request
857			.properties_mut()
858			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
859		let op = aws_smithy_http::operation::Operation::new(
860			request,
861			crate::operation::GetIdentityProfile::new(),
862		)
863		.with_metadata(aws_smithy_http::operation::Metadata::new(
864			"GetIdentityProfile",
865			"IdentityService",
866		));
867		Ok(op)
868	}
869	/// Creates a new builder-style object to manufacture [`GetIdentityProfileInput`](crate::input::GetIdentityProfileInput)
870	pub fn builder() -> crate::input::get_identity_profile_input::Builder {
871		crate::input::get_identity_profile_input::Builder::default()
872	}
873}
874
875/// See [`GetIdentitySelfProfileInput`](crate::input::GetIdentitySelfProfileInput)
876pub mod get_identity_self_profile_input {
877	/// A builder for [`GetIdentitySelfProfileInput`](crate::input::GetIdentitySelfProfileInput)
878	#[non_exhaustive]
879	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
880	pub struct Builder {
881		pub(crate) watch_index: std::option::Option<std::string::String>,
882	}
883	impl Builder {
884		/// A query parameter denoting the requests watch index.
885		pub fn watch_index(mut self, input: impl Into<std::string::String>) -> Self {
886			self.watch_index = Some(input.into());
887			self
888		}
889		/// A query parameter denoting the requests watch index.
890		pub fn set_watch_index(mut self, input: std::option::Option<std::string::String>) -> Self {
891			self.watch_index = input;
892			self
893		}
894		/// Consumes the builder and constructs a [`GetIdentitySelfProfileInput`](crate::input::GetIdentitySelfProfileInput)
895		pub fn build(
896			self,
897		) -> std::result::Result<
898			crate::input::GetIdentitySelfProfileInput,
899			aws_smithy_http::operation::BuildError,
900		> {
901			Ok(crate::input::GetIdentitySelfProfileInput {
902				watch_index: self.watch_index,
903			})
904		}
905	}
906}
907#[doc(hidden)]
908pub type GetIdentitySelfProfileInputOperationOutputAlias = crate::operation::GetIdentitySelfProfile;
909#[doc(hidden)]
910pub type GetIdentitySelfProfileInputOperationRetryAlias = ();
911impl GetIdentitySelfProfileInput {
912	/// Consumes the builder and constructs an Operation<[`GetIdentitySelfProfile`](crate::operation::GetIdentitySelfProfile)>
913	#[allow(unused_mut)]
914	#[allow(clippy::let_and_return)]
915	#[allow(clippy::needless_borrow)]
916	pub async fn make_operation(
917		&self,
918		_config: &crate::config::Config,
919	) -> std::result::Result<
920		aws_smithy_http::operation::Operation<crate::operation::GetIdentitySelfProfile, ()>,
921		aws_smithy_http::operation::BuildError,
922	> {
923		let mut request = {
924			fn uri_base(
925				_input: &crate::input::GetIdentitySelfProfileInput,
926				output: &mut String,
927			) -> Result<(), aws_smithy_http::operation::BuildError> {
928				write!(output, "/identities/self/profile").expect("formatting should succeed");
929				Ok(())
930			}
931			fn uri_query(
932				_input: &crate::input::GetIdentitySelfProfileInput,
933				mut output: &mut String,
934			) -> Result<(), aws_smithy_http::operation::BuildError> {
935				let mut query = aws_smithy_http::query::Writer::new(&mut output);
936				if let Some(inner_9) = &_input.watch_index {
937					query.push_kv("watch_index", &aws_smithy_http::query::fmt_string(&inner_9));
938				}
939				Ok(())
940			}
941			#[allow(clippy::unnecessary_wraps)]
942			fn update_http_builder(
943				input: &crate::input::GetIdentitySelfProfileInput,
944				_config: &crate::config::Config,
945				builder: http::request::Builder,
946			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
947			{
948				let mut _uri = String::new();
949				_uri = format!("{}{}", _config.uri.clone(), _uri);
950				uri_base(input, &mut _uri)?;
951				uri_query(input, &mut _uri)?;
952				Ok(builder.method("GET").uri(_uri))
953			}
954			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
955			let mut builder = if let Some(auth) = &_config.auth {
956				builder.header(http::header::AUTHORIZATION, auth.clone())
957			} else {
958				builder
959			};
960			builder
961		};
962		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
963		#[allow(clippy::useless_conversion)]
964		let body = aws_smithy_http::body::SdkBody::from("");
965		let request = request.body(body).expect("should be valid request");
966		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
967		request
968			.properties_mut()
969			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
970		let op = aws_smithy_http::operation::Operation::new(
971			request,
972			crate::operation::GetIdentitySelfProfile::new(),
973		)
974		.with_metadata(aws_smithy_http::operation::Metadata::new(
975			"GetIdentitySelfProfile",
976			"IdentityService",
977		));
978		Ok(op)
979	}
980	/// Creates a new builder-style object to manufacture [`GetIdentitySelfProfileInput`](crate::input::GetIdentitySelfProfileInput)
981	pub fn builder() -> crate::input::get_identity_self_profile_input::Builder {
982		crate::input::get_identity_self_profile_input::Builder::default()
983	}
984}
985
986/// See [`GetIdentitySummariesInput`](crate::input::GetIdentitySummariesInput)
987pub mod get_identity_summaries_input {
988	/// A builder for [`GetIdentitySummariesInput`](crate::input::GetIdentitySummariesInput)
989	#[non_exhaustive]
990	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
991	pub struct Builder {
992		pub(crate) identity_ids: std::option::Option<std::vec::Vec<std::string::String>>,
993	}
994	impl Builder {
995		/// Appends an item to `identity_ids`.
996		///
997		/// To override the contents of this collection use [`set_identity_ids`](Self::set_identity_ids).
998		///
999		/// A list of identity IDs.
1000		pub fn identity_ids(mut self, input: impl Into<std::string::String>) -> Self {
1001			let mut v = self.identity_ids.unwrap_or_default();
1002			v.push(input.into());
1003			self.identity_ids = Some(v);
1004			self
1005		}
1006		/// A list of identity IDs.
1007		pub fn set_identity_ids(
1008			mut self,
1009			input: std::option::Option<std::vec::Vec<std::string::String>>,
1010		) -> Self {
1011			self.identity_ids = input;
1012			self
1013		}
1014		/// Consumes the builder and constructs a [`GetIdentitySummariesInput`](crate::input::GetIdentitySummariesInput)
1015		pub fn build(
1016			self,
1017		) -> std::result::Result<
1018			crate::input::GetIdentitySummariesInput,
1019			aws_smithy_http::operation::BuildError,
1020		> {
1021			Ok(crate::input::GetIdentitySummariesInput {
1022				identity_ids: self.identity_ids,
1023			})
1024		}
1025	}
1026}
1027#[doc(hidden)]
1028pub type GetIdentitySummariesInputOperationOutputAlias = crate::operation::GetIdentitySummaries;
1029#[doc(hidden)]
1030pub type GetIdentitySummariesInputOperationRetryAlias = ();
1031impl GetIdentitySummariesInput {
1032	/// Consumes the builder and constructs an Operation<[`GetIdentitySummaries`](crate::operation::GetIdentitySummaries)>
1033	#[allow(unused_mut)]
1034	#[allow(clippy::let_and_return)]
1035	#[allow(clippy::needless_borrow)]
1036	pub async fn make_operation(
1037		&self,
1038		_config: &crate::config::Config,
1039	) -> std::result::Result<
1040		aws_smithy_http::operation::Operation<crate::operation::GetIdentitySummaries, ()>,
1041		aws_smithy_http::operation::BuildError,
1042	> {
1043		let mut request = {
1044			fn uri_base(
1045				_input: &crate::input::GetIdentitySummariesInput,
1046				output: &mut String,
1047			) -> Result<(), aws_smithy_http::operation::BuildError> {
1048				write!(output, "/identities/batch/summary").expect("formatting should succeed");
1049				Ok(())
1050			}
1051			fn uri_query(
1052				_input: &crate::input::GetIdentitySummariesInput,
1053				mut output: &mut String,
1054			) -> Result<(), aws_smithy_http::operation::BuildError> {
1055				let mut query = aws_smithy_http::query::Writer::new(&mut output);
1056				if let Some(inner_10) = &_input.identity_ids {
1057					for inner_11 in inner_10 {
1058						query.push_kv(
1059							"identity_ids",
1060							&aws_smithy_http::query::fmt_string(&inner_11),
1061						);
1062					}
1063				}
1064				Ok(())
1065			}
1066			#[allow(clippy::unnecessary_wraps)]
1067			fn update_http_builder(
1068				input: &crate::input::GetIdentitySummariesInput,
1069				_config: &crate::config::Config,
1070				builder: http::request::Builder,
1071			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
1072			{
1073				let mut _uri = String::new();
1074				_uri = format!("{}{}", _config.uri.clone(), _uri);
1075				uri_base(input, &mut _uri)?;
1076				uri_query(input, &mut _uri)?;
1077				Ok(builder.method("GET").uri(_uri))
1078			}
1079			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
1080			let mut builder = if let Some(auth) = &_config.auth {
1081				builder.header(http::header::AUTHORIZATION, auth.clone())
1082			} else {
1083				builder
1084			};
1085			builder
1086		};
1087		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
1088		#[allow(clippy::useless_conversion)]
1089		let body = aws_smithy_http::body::SdkBody::from("");
1090		let request = request.body(body).expect("should be valid request");
1091		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
1092		request
1093			.properties_mut()
1094			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
1095		let op = aws_smithy_http::operation::Operation::new(
1096			request,
1097			crate::operation::GetIdentitySummaries::new(),
1098		)
1099		.with_metadata(aws_smithy_http::operation::Metadata::new(
1100			"GetIdentitySummaries",
1101			"IdentityService",
1102		));
1103		Ok(op)
1104	}
1105	/// Creates a new builder-style object to manufacture [`GetIdentitySummariesInput`](crate::input::GetIdentitySummariesInput)
1106	pub fn builder() -> crate::input::get_identity_summaries_input::Builder {
1107		crate::input::get_identity_summaries_input::Builder::default()
1108	}
1109}
1110
1111/// See [`ListActivitiesInput`](crate::input::ListActivitiesInput)
1112pub mod list_activities_input {
1113	/// A builder for [`ListActivitiesInput`](crate::input::ListActivitiesInput)
1114	#[non_exhaustive]
1115	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1116	pub struct Builder {
1117		pub(crate) watch_index: std::option::Option<std::string::String>,
1118	}
1119	impl Builder {
1120		/// A query parameter denoting the requests watch index.
1121		pub fn watch_index(mut self, input: impl Into<std::string::String>) -> Self {
1122			self.watch_index = Some(input.into());
1123			self
1124		}
1125		/// A query parameter denoting the requests watch index.
1126		pub fn set_watch_index(mut self, input: std::option::Option<std::string::String>) -> Self {
1127			self.watch_index = input;
1128			self
1129		}
1130		/// Consumes the builder and constructs a [`ListActivitiesInput`](crate::input::ListActivitiesInput)
1131		pub fn build(
1132			self,
1133		) -> std::result::Result<
1134			crate::input::ListActivitiesInput,
1135			aws_smithy_http::operation::BuildError,
1136		> {
1137			Ok(crate::input::ListActivitiesInput {
1138				watch_index: self.watch_index,
1139			})
1140		}
1141	}
1142}
1143#[doc(hidden)]
1144pub type ListActivitiesInputOperationOutputAlias = crate::operation::ListActivities;
1145#[doc(hidden)]
1146pub type ListActivitiesInputOperationRetryAlias = ();
1147impl ListActivitiesInput {
1148	/// Consumes the builder and constructs an Operation<[`ListActivities`](crate::operation::ListActivities)>
1149	#[allow(unused_mut)]
1150	#[allow(clippy::let_and_return)]
1151	#[allow(clippy::needless_borrow)]
1152	pub async fn make_operation(
1153		&self,
1154		_config: &crate::config::Config,
1155	) -> std::result::Result<
1156		aws_smithy_http::operation::Operation<crate::operation::ListActivities, ()>,
1157		aws_smithy_http::operation::BuildError,
1158	> {
1159		let mut request = {
1160			fn uri_base(
1161				_input: &crate::input::ListActivitiesInput,
1162				output: &mut String,
1163			) -> Result<(), aws_smithy_http::operation::BuildError> {
1164				write!(output, "/activities").expect("formatting should succeed");
1165				Ok(())
1166			}
1167			fn uri_query(
1168				_input: &crate::input::ListActivitiesInput,
1169				mut output: &mut String,
1170			) -> Result<(), aws_smithy_http::operation::BuildError> {
1171				let mut query = aws_smithy_http::query::Writer::new(&mut output);
1172				if let Some(inner_12) = &_input.watch_index {
1173					query.push_kv(
1174						"watch_index",
1175						&aws_smithy_http::query::fmt_string(&inner_12),
1176					);
1177				}
1178				Ok(())
1179			}
1180			#[allow(clippy::unnecessary_wraps)]
1181			fn update_http_builder(
1182				input: &crate::input::ListActivitiesInput,
1183				_config: &crate::config::Config,
1184				builder: http::request::Builder,
1185			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
1186			{
1187				let mut _uri = String::new();
1188				_uri = format!("{}{}", _config.uri.clone(), _uri);
1189				uri_base(input, &mut _uri)?;
1190				uri_query(input, &mut _uri)?;
1191				Ok(builder.method("GET").uri(_uri))
1192			}
1193			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
1194			let mut builder = if let Some(auth) = &_config.auth {
1195				builder.header(http::header::AUTHORIZATION, auth.clone())
1196			} else {
1197				builder
1198			};
1199			builder
1200		};
1201		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
1202		#[allow(clippy::useless_conversion)]
1203		let body = aws_smithy_http::body::SdkBody::from("");
1204		let request = request.body(body).expect("should be valid request");
1205		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
1206		request
1207			.properties_mut()
1208			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
1209		let op = aws_smithy_http::operation::Operation::new(
1210			request,
1211			crate::operation::ListActivities::new(),
1212		)
1213		.with_metadata(aws_smithy_http::operation::Metadata::new(
1214			"ListActivities",
1215			"IdentityService",
1216		));
1217		Ok(op)
1218	}
1219	/// Creates a new builder-style object to manufacture [`ListActivitiesInput`](crate::input::ListActivitiesInput)
1220	pub fn builder() -> crate::input::list_activities_input::Builder {
1221		crate::input::list_activities_input::Builder::default()
1222	}
1223}
1224
1225/// See [`ListFollowersInput`](crate::input::ListFollowersInput)
1226pub mod list_followers_input {
1227	/// A builder for [`ListFollowersInput`](crate::input::ListFollowersInput)
1228	#[non_exhaustive]
1229	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1230	pub struct Builder {
1231		pub(crate) identity_id: std::option::Option<std::string::String>,
1232		pub(crate) anchor: std::option::Option<std::string::String>,
1233		pub(crate) limit: std::option::Option<i32>,
1234	}
1235	impl Builder {
1236		/// A universally unique identifier.
1237		pub fn identity_id(mut self, input: impl Into<std::string::String>) -> Self {
1238			self.identity_id = Some(input.into());
1239			self
1240		}
1241		/// A universally unique identifier.
1242		pub fn set_identity_id(mut self, input: std::option::Option<std::string::String>) -> Self {
1243			self.identity_id = input;
1244			self
1245		}
1246		#[allow(missing_docs)] // documentation missing in model
1247		pub fn anchor(mut self, input: impl Into<std::string::String>) -> Self {
1248			self.anchor = Some(input.into());
1249			self
1250		}
1251		#[allow(missing_docs)] // documentation missing in model
1252		pub fn set_anchor(mut self, input: std::option::Option<std::string::String>) -> Self {
1253			self.anchor = input;
1254			self
1255		}
1256		/// Unsigned 32 bit integer.
1257		pub fn limit(mut self, input: i32) -> Self {
1258			self.limit = Some(input);
1259			self
1260		}
1261		/// Unsigned 32 bit integer.
1262		pub fn set_limit(mut self, input: std::option::Option<i32>) -> Self {
1263			self.limit = input;
1264			self
1265		}
1266		/// Consumes the builder and constructs a [`ListFollowersInput`](crate::input::ListFollowersInput)
1267		pub fn build(
1268			self,
1269		) -> std::result::Result<
1270			crate::input::ListFollowersInput,
1271			aws_smithy_http::operation::BuildError,
1272		> {
1273			Ok(crate::input::ListFollowersInput {
1274				identity_id: self.identity_id,
1275				anchor: self.anchor,
1276				limit: self.limit,
1277			})
1278		}
1279	}
1280}
1281#[doc(hidden)]
1282pub type ListFollowersInputOperationOutputAlias = crate::operation::ListFollowers;
1283#[doc(hidden)]
1284pub type ListFollowersInputOperationRetryAlias = ();
1285impl ListFollowersInput {
1286	/// Consumes the builder and constructs an Operation<[`ListFollowers`](crate::operation::ListFollowers)>
1287	#[allow(unused_mut)]
1288	#[allow(clippy::let_and_return)]
1289	#[allow(clippy::needless_borrow)]
1290	pub async fn make_operation(
1291		&self,
1292		_config: &crate::config::Config,
1293	) -> std::result::Result<
1294		aws_smithy_http::operation::Operation<crate::operation::ListFollowers, ()>,
1295		aws_smithy_http::operation::BuildError,
1296	> {
1297		let mut request = {
1298			fn uri_base(
1299				_input: &crate::input::ListFollowersInput,
1300				output: &mut String,
1301			) -> Result<(), aws_smithy_http::operation::BuildError> {
1302				let input_13 = &_input.identity_id;
1303				let input_13 = input_13.as_ref().ok_or(
1304					aws_smithy_http::operation::BuildError::MissingField {
1305						field: "identity_id",
1306						details: "cannot be empty or unset",
1307					},
1308				)?;
1309				let identity_id = aws_smithy_http::label::fmt_string(input_13, false);
1310				if identity_id.is_empty() {
1311					return Err(aws_smithy_http::operation::BuildError::MissingField {
1312						field: "identity_id",
1313						details: "cannot be empty or unset",
1314					});
1315				}
1316				write!(
1317					output,
1318					"/identities/{identity_id}/followers",
1319					identity_id = identity_id
1320				)
1321				.expect("formatting should succeed");
1322				Ok(())
1323			}
1324			fn uri_query(
1325				_input: &crate::input::ListFollowersInput,
1326				mut output: &mut String,
1327			) -> Result<(), aws_smithy_http::operation::BuildError> {
1328				let mut query = aws_smithy_http::query::Writer::new(&mut output);
1329				if let Some(inner_14) = &_input.anchor {
1330					query.push_kv("anchor", &aws_smithy_http::query::fmt_string(&inner_14));
1331				}
1332				if let Some(inner_15) = &_input.limit {
1333					query.push_kv(
1334						"limit",
1335						aws_smithy_types::primitive::Encoder::from(*inner_15).encode(),
1336					);
1337				}
1338				Ok(())
1339			}
1340			#[allow(clippy::unnecessary_wraps)]
1341			fn update_http_builder(
1342				input: &crate::input::ListFollowersInput,
1343				_config: &crate::config::Config,
1344				builder: http::request::Builder,
1345			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
1346			{
1347				let mut _uri = String::new();
1348				_uri = format!("{}{}", _config.uri.clone(), _uri);
1349				uri_base(input, &mut _uri)?;
1350				uri_query(input, &mut _uri)?;
1351				Ok(builder.method("GET").uri(_uri))
1352			}
1353			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
1354			let mut builder = if let Some(auth) = &_config.auth {
1355				builder.header(http::header::AUTHORIZATION, auth.clone())
1356			} else {
1357				builder
1358			};
1359			builder
1360		};
1361		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
1362		#[allow(clippy::useless_conversion)]
1363		let body = aws_smithy_http::body::SdkBody::from("");
1364		let request = request.body(body).expect("should be valid request");
1365		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
1366		request
1367			.properties_mut()
1368			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
1369		let op = aws_smithy_http::operation::Operation::new(
1370			request,
1371			crate::operation::ListFollowers::new(),
1372		)
1373		.with_metadata(aws_smithy_http::operation::Metadata::new(
1374			"ListFollowers",
1375			"IdentityService",
1376		));
1377		Ok(op)
1378	}
1379	/// Creates a new builder-style object to manufacture [`ListFollowersInput`](crate::input::ListFollowersInput)
1380	pub fn builder() -> crate::input::list_followers_input::Builder {
1381		crate::input::list_followers_input::Builder::default()
1382	}
1383}
1384
1385/// See [`ListFollowingInput`](crate::input::ListFollowingInput)
1386pub mod list_following_input {
1387	/// A builder for [`ListFollowingInput`](crate::input::ListFollowingInput)
1388	#[non_exhaustive]
1389	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1390	pub struct Builder {
1391		pub(crate) identity_id: std::option::Option<std::string::String>,
1392		pub(crate) anchor: std::option::Option<std::string::String>,
1393		pub(crate) limit: std::option::Option<i32>,
1394	}
1395	impl Builder {
1396		/// A universally unique identifier.
1397		pub fn identity_id(mut self, input: impl Into<std::string::String>) -> Self {
1398			self.identity_id = Some(input.into());
1399			self
1400		}
1401		/// A universally unique identifier.
1402		pub fn set_identity_id(mut self, input: std::option::Option<std::string::String>) -> Self {
1403			self.identity_id = input;
1404			self
1405		}
1406		#[allow(missing_docs)] // documentation missing in model
1407		pub fn anchor(mut self, input: impl Into<std::string::String>) -> Self {
1408			self.anchor = Some(input.into());
1409			self
1410		}
1411		#[allow(missing_docs)] // documentation missing in model
1412		pub fn set_anchor(mut self, input: std::option::Option<std::string::String>) -> Self {
1413			self.anchor = input;
1414			self
1415		}
1416		/// Unsigned 32 bit integer.
1417		pub fn limit(mut self, input: i32) -> Self {
1418			self.limit = Some(input);
1419			self
1420		}
1421		/// Unsigned 32 bit integer.
1422		pub fn set_limit(mut self, input: std::option::Option<i32>) -> Self {
1423			self.limit = input;
1424			self
1425		}
1426		/// Consumes the builder and constructs a [`ListFollowingInput`](crate::input::ListFollowingInput)
1427		pub fn build(
1428			self,
1429		) -> std::result::Result<
1430			crate::input::ListFollowingInput,
1431			aws_smithy_http::operation::BuildError,
1432		> {
1433			Ok(crate::input::ListFollowingInput {
1434				identity_id: self.identity_id,
1435				anchor: self.anchor,
1436				limit: self.limit,
1437			})
1438		}
1439	}
1440}
1441#[doc(hidden)]
1442pub type ListFollowingInputOperationOutputAlias = crate::operation::ListFollowing;
1443#[doc(hidden)]
1444pub type ListFollowingInputOperationRetryAlias = ();
1445impl ListFollowingInput {
1446	/// Consumes the builder and constructs an Operation<[`ListFollowing`](crate::operation::ListFollowing)>
1447	#[allow(unused_mut)]
1448	#[allow(clippy::let_and_return)]
1449	#[allow(clippy::needless_borrow)]
1450	pub async fn make_operation(
1451		&self,
1452		_config: &crate::config::Config,
1453	) -> std::result::Result<
1454		aws_smithy_http::operation::Operation<crate::operation::ListFollowing, ()>,
1455		aws_smithy_http::operation::BuildError,
1456	> {
1457		let mut request = {
1458			fn uri_base(
1459				_input: &crate::input::ListFollowingInput,
1460				output: &mut String,
1461			) -> Result<(), aws_smithy_http::operation::BuildError> {
1462				let input_16 = &_input.identity_id;
1463				let input_16 = input_16.as_ref().ok_or(
1464					aws_smithy_http::operation::BuildError::MissingField {
1465						field: "identity_id",
1466						details: "cannot be empty or unset",
1467					},
1468				)?;
1469				let identity_id = aws_smithy_http::label::fmt_string(input_16, false);
1470				if identity_id.is_empty() {
1471					return Err(aws_smithy_http::operation::BuildError::MissingField {
1472						field: "identity_id",
1473						details: "cannot be empty or unset",
1474					});
1475				}
1476				write!(
1477					output,
1478					"/identities/{identity_id}/following",
1479					identity_id = identity_id
1480				)
1481				.expect("formatting should succeed");
1482				Ok(())
1483			}
1484			fn uri_query(
1485				_input: &crate::input::ListFollowingInput,
1486				mut output: &mut String,
1487			) -> Result<(), aws_smithy_http::operation::BuildError> {
1488				let mut query = aws_smithy_http::query::Writer::new(&mut output);
1489				if let Some(inner_17) = &_input.anchor {
1490					query.push_kv("anchor", &aws_smithy_http::query::fmt_string(&inner_17));
1491				}
1492				if let Some(inner_18) = &_input.limit {
1493					query.push_kv(
1494						"limit",
1495						aws_smithy_types::primitive::Encoder::from(*inner_18).encode(),
1496					);
1497				}
1498				Ok(())
1499			}
1500			#[allow(clippy::unnecessary_wraps)]
1501			fn update_http_builder(
1502				input: &crate::input::ListFollowingInput,
1503				_config: &crate::config::Config,
1504				builder: http::request::Builder,
1505			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
1506			{
1507				let mut _uri = String::new();
1508				_uri = format!("{}{}", _config.uri.clone(), _uri);
1509				uri_base(input, &mut _uri)?;
1510				uri_query(input, &mut _uri)?;
1511				Ok(builder.method("GET").uri(_uri))
1512			}
1513			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
1514			let mut builder = if let Some(auth) = &_config.auth {
1515				builder.header(http::header::AUTHORIZATION, auth.clone())
1516			} else {
1517				builder
1518			};
1519			builder
1520		};
1521		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
1522		#[allow(clippy::useless_conversion)]
1523		let body = aws_smithy_http::body::SdkBody::from("");
1524		let request = request.body(body).expect("should be valid request");
1525		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
1526		request
1527			.properties_mut()
1528			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
1529		let op = aws_smithy_http::operation::Operation::new(
1530			request,
1531			crate::operation::ListFollowing::new(),
1532		)
1533		.with_metadata(aws_smithy_http::operation::Metadata::new(
1534			"ListFollowing",
1535			"IdentityService",
1536		));
1537		Ok(op)
1538	}
1539	/// Creates a new builder-style object to manufacture [`ListFollowingInput`](crate::input::ListFollowingInput)
1540	pub fn builder() -> crate::input::list_following_input::Builder {
1541		crate::input::list_following_input::Builder::default()
1542	}
1543}
1544
1545/// See [`ListFriendsInput`](crate::input::ListFriendsInput)
1546pub mod list_friends_input {
1547	/// A builder for [`ListFriendsInput`](crate::input::ListFriendsInput)
1548	#[non_exhaustive]
1549	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1550	pub struct Builder {
1551		pub(crate) anchor: std::option::Option<std::string::String>,
1552		pub(crate) limit: std::option::Option<i32>,
1553	}
1554	impl Builder {
1555		#[allow(missing_docs)] // documentation missing in model
1556		pub fn anchor(mut self, input: impl Into<std::string::String>) -> Self {
1557			self.anchor = Some(input.into());
1558			self
1559		}
1560		#[allow(missing_docs)] // documentation missing in model
1561		pub fn set_anchor(mut self, input: std::option::Option<std::string::String>) -> Self {
1562			self.anchor = input;
1563			self
1564		}
1565		/// Unsigned 32 bit integer.
1566		pub fn limit(mut self, input: i32) -> Self {
1567			self.limit = Some(input);
1568			self
1569		}
1570		/// Unsigned 32 bit integer.
1571		pub fn set_limit(mut self, input: std::option::Option<i32>) -> Self {
1572			self.limit = input;
1573			self
1574		}
1575		/// Consumes the builder and constructs a [`ListFriendsInput`](crate::input::ListFriendsInput)
1576		pub fn build(
1577			self,
1578		) -> std::result::Result<
1579			crate::input::ListFriendsInput,
1580			aws_smithy_http::operation::BuildError,
1581		> {
1582			Ok(crate::input::ListFriendsInput {
1583				anchor: self.anchor,
1584				limit: self.limit,
1585			})
1586		}
1587	}
1588}
1589#[doc(hidden)]
1590pub type ListFriendsInputOperationOutputAlias = crate::operation::ListFriends;
1591#[doc(hidden)]
1592pub type ListFriendsInputOperationRetryAlias = ();
1593impl ListFriendsInput {
1594	/// Consumes the builder and constructs an Operation<[`ListFriends`](crate::operation::ListFriends)>
1595	#[allow(unused_mut)]
1596	#[allow(clippy::let_and_return)]
1597	#[allow(clippy::needless_borrow)]
1598	pub async fn make_operation(
1599		&self,
1600		_config: &crate::config::Config,
1601	) -> std::result::Result<
1602		aws_smithy_http::operation::Operation<crate::operation::ListFriends, ()>,
1603		aws_smithy_http::operation::BuildError,
1604	> {
1605		let mut request = {
1606			fn uri_base(
1607				_input: &crate::input::ListFriendsInput,
1608				output: &mut String,
1609			) -> Result<(), aws_smithy_http::operation::BuildError> {
1610				write!(output, "/identities/self/friends").expect("formatting should succeed");
1611				Ok(())
1612			}
1613			fn uri_query(
1614				_input: &crate::input::ListFriendsInput,
1615				mut output: &mut String,
1616			) -> Result<(), aws_smithy_http::operation::BuildError> {
1617				let mut query = aws_smithy_http::query::Writer::new(&mut output);
1618				if let Some(inner_19) = &_input.anchor {
1619					query.push_kv("anchor", &aws_smithy_http::query::fmt_string(&inner_19));
1620				}
1621				if let Some(inner_20) = &_input.limit {
1622					query.push_kv(
1623						"limit",
1624						aws_smithy_types::primitive::Encoder::from(*inner_20).encode(),
1625					);
1626				}
1627				Ok(())
1628			}
1629			#[allow(clippy::unnecessary_wraps)]
1630			fn update_http_builder(
1631				input: &crate::input::ListFriendsInput,
1632				_config: &crate::config::Config,
1633				builder: http::request::Builder,
1634			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
1635			{
1636				let mut _uri = String::new();
1637				_uri = format!("{}{}", _config.uri.clone(), _uri);
1638				uri_base(input, &mut _uri)?;
1639				uri_query(input, &mut _uri)?;
1640				Ok(builder.method("GET").uri(_uri))
1641			}
1642			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
1643			let mut builder = if let Some(auth) = &_config.auth {
1644				builder.header(http::header::AUTHORIZATION, auth.clone())
1645			} else {
1646				builder
1647			};
1648			builder
1649		};
1650		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
1651		#[allow(clippy::useless_conversion)]
1652		let body = aws_smithy_http::body::SdkBody::from("");
1653		let request = request.body(body).expect("should be valid request");
1654		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
1655		request
1656			.properties_mut()
1657			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
1658		let op = aws_smithy_http::operation::Operation::new(
1659			request,
1660			crate::operation::ListFriends::new(),
1661		)
1662		.with_metadata(aws_smithy_http::operation::Metadata::new(
1663			"ListFriends",
1664			"IdentityService",
1665		));
1666		Ok(op)
1667	}
1668	/// Creates a new builder-style object to manufacture [`ListFriendsInput`](crate::input::ListFriendsInput)
1669	pub fn builder() -> crate::input::list_friends_input::Builder {
1670		crate::input::list_friends_input::Builder::default()
1671	}
1672}
1673
1674/// See [`ListMutualFriendsInput`](crate::input::ListMutualFriendsInput)
1675pub mod list_mutual_friends_input {
1676	/// A builder for [`ListMutualFriendsInput`](crate::input::ListMutualFriendsInput)
1677	#[non_exhaustive]
1678	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1679	pub struct Builder {
1680		pub(crate) identity_id: std::option::Option<std::string::String>,
1681		pub(crate) anchor: std::option::Option<std::string::String>,
1682		pub(crate) limit: std::option::Option<i32>,
1683	}
1684	impl Builder {
1685		/// A universally unique identifier.
1686		pub fn identity_id(mut self, input: impl Into<std::string::String>) -> Self {
1687			self.identity_id = Some(input.into());
1688			self
1689		}
1690		/// A universally unique identifier.
1691		pub fn set_identity_id(mut self, input: std::option::Option<std::string::String>) -> Self {
1692			self.identity_id = input;
1693			self
1694		}
1695		#[allow(missing_docs)] // documentation missing in model
1696		pub fn anchor(mut self, input: impl Into<std::string::String>) -> Self {
1697			self.anchor = Some(input.into());
1698			self
1699		}
1700		#[allow(missing_docs)] // documentation missing in model
1701		pub fn set_anchor(mut self, input: std::option::Option<std::string::String>) -> Self {
1702			self.anchor = input;
1703			self
1704		}
1705		/// Unsigned 32 bit integer.
1706		pub fn limit(mut self, input: i32) -> Self {
1707			self.limit = Some(input);
1708			self
1709		}
1710		/// Unsigned 32 bit integer.
1711		pub fn set_limit(mut self, input: std::option::Option<i32>) -> Self {
1712			self.limit = input;
1713			self
1714		}
1715		/// Consumes the builder and constructs a [`ListMutualFriendsInput`](crate::input::ListMutualFriendsInput)
1716		pub fn build(
1717			self,
1718		) -> std::result::Result<
1719			crate::input::ListMutualFriendsInput,
1720			aws_smithy_http::operation::BuildError,
1721		> {
1722			Ok(crate::input::ListMutualFriendsInput {
1723				identity_id: self.identity_id,
1724				anchor: self.anchor,
1725				limit: self.limit,
1726			})
1727		}
1728	}
1729}
1730#[doc(hidden)]
1731pub type ListMutualFriendsInputOperationOutputAlias = crate::operation::ListMutualFriends;
1732#[doc(hidden)]
1733pub type ListMutualFriendsInputOperationRetryAlias = ();
1734impl ListMutualFriendsInput {
1735	/// Consumes the builder and constructs an Operation<[`ListMutualFriends`](crate::operation::ListMutualFriends)>
1736	#[allow(unused_mut)]
1737	#[allow(clippy::let_and_return)]
1738	#[allow(clippy::needless_borrow)]
1739	pub async fn make_operation(
1740		&self,
1741		_config: &crate::config::Config,
1742	) -> std::result::Result<
1743		aws_smithy_http::operation::Operation<crate::operation::ListMutualFriends, ()>,
1744		aws_smithy_http::operation::BuildError,
1745	> {
1746		let mut request = {
1747			fn uri_base(
1748				_input: &crate::input::ListMutualFriendsInput,
1749				output: &mut String,
1750			) -> Result<(), aws_smithy_http::operation::BuildError> {
1751				let input_21 = &_input.identity_id;
1752				let input_21 = input_21.as_ref().ok_or(
1753					aws_smithy_http::operation::BuildError::MissingField {
1754						field: "identity_id",
1755						details: "cannot be empty or unset",
1756					},
1757				)?;
1758				let identity_id = aws_smithy_http::label::fmt_string(input_21, false);
1759				if identity_id.is_empty() {
1760					return Err(aws_smithy_http::operation::BuildError::MissingField {
1761						field: "identity_id",
1762						details: "cannot be empty or unset",
1763					});
1764				}
1765				write!(
1766					output,
1767					"/identities/{identity_id}/mutual-friends",
1768					identity_id = identity_id
1769				)
1770				.expect("formatting should succeed");
1771				Ok(())
1772			}
1773			fn uri_query(
1774				_input: &crate::input::ListMutualFriendsInput,
1775				mut output: &mut String,
1776			) -> Result<(), aws_smithy_http::operation::BuildError> {
1777				let mut query = aws_smithy_http::query::Writer::new(&mut output);
1778				if let Some(inner_22) = &_input.anchor {
1779					query.push_kv("anchor", &aws_smithy_http::query::fmt_string(&inner_22));
1780				}
1781				if let Some(inner_23) = &_input.limit {
1782					query.push_kv(
1783						"limit",
1784						aws_smithy_types::primitive::Encoder::from(*inner_23).encode(),
1785					);
1786				}
1787				Ok(())
1788			}
1789			#[allow(clippy::unnecessary_wraps)]
1790			fn update_http_builder(
1791				input: &crate::input::ListMutualFriendsInput,
1792				_config: &crate::config::Config,
1793				builder: http::request::Builder,
1794			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
1795			{
1796				let mut _uri = String::new();
1797				_uri = format!("{}{}", _config.uri.clone(), _uri);
1798				uri_base(input, &mut _uri)?;
1799				uri_query(input, &mut _uri)?;
1800				Ok(builder.method("GET").uri(_uri))
1801			}
1802			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
1803			let mut builder = if let Some(auth) = &_config.auth {
1804				builder.header(http::header::AUTHORIZATION, auth.clone())
1805			} else {
1806				builder
1807			};
1808			builder
1809		};
1810		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
1811		#[allow(clippy::useless_conversion)]
1812		let body = aws_smithy_http::body::SdkBody::from("");
1813		let request = request.body(body).expect("should be valid request");
1814		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
1815		request
1816			.properties_mut()
1817			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
1818		let op = aws_smithy_http::operation::Operation::new(
1819			request,
1820			crate::operation::ListMutualFriends::new(),
1821		)
1822		.with_metadata(aws_smithy_http::operation::Metadata::new(
1823			"ListMutualFriends",
1824			"IdentityService",
1825		));
1826		Ok(op)
1827	}
1828	/// Creates a new builder-style object to manufacture [`ListMutualFriendsInput`](crate::input::ListMutualFriendsInput)
1829	pub fn builder() -> crate::input::list_mutual_friends_input::Builder {
1830		crate::input::list_mutual_friends_input::Builder::default()
1831	}
1832}
1833
1834/// See [`PrepareGameLinkInput`](crate::input::PrepareGameLinkInput)
1835pub mod prepare_game_link_input {
1836	/// A builder for [`PrepareGameLinkInput`](crate::input::PrepareGameLinkInput)
1837	#[non_exhaustive]
1838	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1839	pub struct Builder {}
1840	impl Builder {
1841		/// Consumes the builder and constructs a [`PrepareGameLinkInput`](crate::input::PrepareGameLinkInput)
1842		pub fn build(
1843			self,
1844		) -> std::result::Result<
1845			crate::input::PrepareGameLinkInput,
1846			aws_smithy_http::operation::BuildError,
1847		> {
1848			Ok(crate::input::PrepareGameLinkInput {})
1849		}
1850	}
1851}
1852#[doc(hidden)]
1853pub type PrepareGameLinkInputOperationOutputAlias = crate::operation::PrepareGameLink;
1854#[doc(hidden)]
1855pub type PrepareGameLinkInputOperationRetryAlias = ();
1856impl PrepareGameLinkInput {
1857	/// Consumes the builder and constructs an Operation<[`PrepareGameLink`](crate::operation::PrepareGameLink)>
1858	#[allow(unused_mut)]
1859	#[allow(clippy::let_and_return)]
1860	#[allow(clippy::needless_borrow)]
1861	pub async fn make_operation(
1862		&self,
1863		_config: &crate::config::Config,
1864	) -> std::result::Result<
1865		aws_smithy_http::operation::Operation<crate::operation::PrepareGameLink, ()>,
1866		aws_smithy_http::operation::BuildError,
1867	> {
1868		let mut request = {
1869			fn uri_base(
1870				_input: &crate::input::PrepareGameLinkInput,
1871				output: &mut String,
1872			) -> Result<(), aws_smithy_http::operation::BuildError> {
1873				write!(output, "/game-links").expect("formatting should succeed");
1874				Ok(())
1875			}
1876			#[allow(clippy::unnecessary_wraps)]
1877			fn update_http_builder(
1878				input: &crate::input::PrepareGameLinkInput,
1879				_config: &crate::config::Config,
1880				builder: http::request::Builder,
1881			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
1882			{
1883				let mut _uri = String::new();
1884				_uri = format!("{}{}", _config.uri.clone(), _uri);
1885				uri_base(input, &mut _uri)?;
1886				Ok(builder.method("POST").uri(_uri))
1887			}
1888			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
1889			let mut builder = if let Some(auth) = &_config.auth {
1890				builder.header(http::header::AUTHORIZATION, auth.clone())
1891			} else {
1892				builder
1893			};
1894			builder
1895		};
1896		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
1897		#[allow(clippy::useless_conversion)]
1898		let body = aws_smithy_http::body::SdkBody::from("{}");
1899		let request = request.body(body).expect("should be valid request");
1900		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
1901		request
1902			.properties_mut()
1903			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
1904		let op = aws_smithy_http::operation::Operation::new(
1905			request,
1906			crate::operation::PrepareGameLink::new(),
1907		)
1908		.with_metadata(aws_smithy_http::operation::Metadata::new(
1909			"PrepareGameLink",
1910			"IdentityService",
1911		));
1912		Ok(op)
1913	}
1914	/// Creates a new builder-style object to manufacture [`PrepareGameLinkInput`](crate::input::PrepareGameLinkInput)
1915	pub fn builder() -> crate::input::prepare_game_link_input::Builder {
1916		crate::input::prepare_game_link_input::Builder::default()
1917	}
1918}
1919
1920/// See [`PrepareIdentityAvatarUploadInput`](crate::input::PrepareIdentityAvatarUploadInput)
1921pub mod prepare_identity_avatar_upload_input {
1922	/// A builder for [`PrepareIdentityAvatarUploadInput`](crate::input::PrepareIdentityAvatarUploadInput)
1923	#[non_exhaustive]
1924	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
1925	pub struct Builder {
1926		pub(crate) path: std::option::Option<std::string::String>,
1927		pub(crate) mime: std::option::Option<std::string::String>,
1928		pub(crate) content_length: std::option::Option<i64>,
1929	}
1930	impl Builder {
1931		/// The path/filename of the identity avatar.
1932		pub fn path(mut self, input: impl Into<std::string::String>) -> Self {
1933			self.path = Some(input.into());
1934			self
1935		}
1936		/// The path/filename of the identity avatar.
1937		pub fn set_path(mut self, input: std::option::Option<std::string::String>) -> Self {
1938			self.path = input;
1939			self
1940		}
1941		/// The MIME type of the identity avatar.
1942		pub fn mime(mut self, input: impl Into<std::string::String>) -> Self {
1943			self.mime = Some(input.into());
1944			self
1945		}
1946		/// The MIME type of the identity avatar.
1947		pub fn set_mime(mut self, input: std::option::Option<std::string::String>) -> Self {
1948			self.mime = input;
1949			self
1950		}
1951		/// Unsigned 64 bit integer.
1952		pub fn content_length(mut self, input: i64) -> Self {
1953			self.content_length = Some(input);
1954			self
1955		}
1956		/// Unsigned 64 bit integer.
1957		pub fn set_content_length(mut self, input: std::option::Option<i64>) -> Self {
1958			self.content_length = input;
1959			self
1960		}
1961		/// Consumes the builder and constructs a [`PrepareIdentityAvatarUploadInput`](crate::input::PrepareIdentityAvatarUploadInput)
1962		pub fn build(
1963			self,
1964		) -> std::result::Result<
1965			crate::input::PrepareIdentityAvatarUploadInput,
1966			aws_smithy_http::operation::BuildError,
1967		> {
1968			Ok(crate::input::PrepareIdentityAvatarUploadInput {
1969				path: self.path,
1970				mime: self.mime,
1971				content_length: self.content_length,
1972			})
1973		}
1974	}
1975}
1976#[doc(hidden)]
1977pub type PrepareIdentityAvatarUploadInputOperationOutputAlias =
1978	crate::operation::PrepareIdentityAvatarUpload;
1979#[doc(hidden)]
1980pub type PrepareIdentityAvatarUploadInputOperationRetryAlias = ();
1981impl PrepareIdentityAvatarUploadInput {
1982	/// Consumes the builder and constructs an Operation<[`PrepareIdentityAvatarUpload`](crate::operation::PrepareIdentityAvatarUpload)>
1983	#[allow(unused_mut)]
1984	#[allow(clippy::let_and_return)]
1985	#[allow(clippy::needless_borrow)]
1986	pub async fn make_operation(
1987		&self,
1988		_config: &crate::config::Config,
1989	) -> std::result::Result<
1990		aws_smithy_http::operation::Operation<crate::operation::PrepareIdentityAvatarUpload, ()>,
1991		aws_smithy_http::operation::BuildError,
1992	> {
1993		let mut request = {
1994			fn uri_base(
1995				_input: &crate::input::PrepareIdentityAvatarUploadInput,
1996				output: &mut String,
1997			) -> Result<(), aws_smithy_http::operation::BuildError> {
1998				write!(output, "/identities/avatar-upload/prepare")
1999					.expect("formatting should succeed");
2000				Ok(())
2001			}
2002			#[allow(clippy::unnecessary_wraps)]
2003			fn update_http_builder(
2004				input: &crate::input::PrepareIdentityAvatarUploadInput,
2005				_config: &crate::config::Config,
2006				builder: http::request::Builder,
2007			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
2008			{
2009				let mut _uri = String::new();
2010				_uri = format!("{}{}", _config.uri.clone(), _uri);
2011				uri_base(input, &mut _uri)?;
2012				Ok(builder.method("POST").uri(_uri))
2013			}
2014			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
2015			let mut builder = if let Some(auth) = &_config.auth {
2016				builder.header(http::header::AUTHORIZATION, auth.clone())
2017			} else {
2018				builder
2019			};
2020			builder = aws_smithy_http::header::set_request_header_if_absent(
2021				builder,
2022				http::header::CONTENT_TYPE,
2023				"application/json",
2024			);
2025			builder
2026		};
2027		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
2028		#[allow(clippy::useless_conversion)]let body = aws_smithy_http::body::SdkBody::from(
2029            crate::operation_ser::serialize_operation_crate_operation_prepare_identity_avatar_upload(&self)?
2030        );
2031		if let Some(content_length) = body.content_length() {
2032			request = aws_smithy_http::header::set_request_header_if_absent(
2033				request,
2034				http::header::CONTENT_LENGTH,
2035				content_length,
2036			);
2037		}
2038		let request = request.body(body).expect("should be valid request");
2039		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
2040		request
2041			.properties_mut()
2042			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
2043		let op = aws_smithy_http::operation::Operation::new(
2044			request,
2045			crate::operation::PrepareIdentityAvatarUpload::new(),
2046		)
2047		.with_metadata(aws_smithy_http::operation::Metadata::new(
2048			"PrepareIdentityAvatarUpload",
2049			"IdentityService",
2050		));
2051		Ok(op)
2052	}
2053	/// Creates a new builder-style object to manufacture [`PrepareIdentityAvatarUploadInput`](crate::input::PrepareIdentityAvatarUploadInput)
2054	pub fn builder() -> crate::input::prepare_identity_avatar_upload_input::Builder {
2055		crate::input::prepare_identity_avatar_upload_input::Builder::default()
2056	}
2057}
2058
2059/// See [`RemoveIdentityGameActivityInput`](crate::input::RemoveIdentityGameActivityInput)
2060pub mod remove_identity_game_activity_input {
2061	/// A builder for [`RemoveIdentityGameActivityInput`](crate::input::RemoveIdentityGameActivityInput)
2062	#[non_exhaustive]
2063	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
2064	pub struct Builder {}
2065	impl Builder {
2066		/// Consumes the builder and constructs a [`RemoveIdentityGameActivityInput`](crate::input::RemoveIdentityGameActivityInput)
2067		pub fn build(
2068			self,
2069		) -> std::result::Result<
2070			crate::input::RemoveIdentityGameActivityInput,
2071			aws_smithy_http::operation::BuildError,
2072		> {
2073			Ok(crate::input::RemoveIdentityGameActivityInput {})
2074		}
2075	}
2076}
2077#[doc(hidden)]
2078pub type RemoveIdentityGameActivityInputOperationOutputAlias =
2079	crate::operation::RemoveIdentityGameActivity;
2080#[doc(hidden)]
2081pub type RemoveIdentityGameActivityInputOperationRetryAlias = ();
2082impl RemoveIdentityGameActivityInput {
2083	/// Consumes the builder and constructs an Operation<[`RemoveIdentityGameActivity`](crate::operation::RemoveIdentityGameActivity)>
2084	#[allow(unused_mut)]
2085	#[allow(clippy::let_and_return)]
2086	#[allow(clippy::needless_borrow)]
2087	pub async fn make_operation(
2088		&self,
2089		_config: &crate::config::Config,
2090	) -> std::result::Result<
2091		aws_smithy_http::operation::Operation<crate::operation::RemoveIdentityGameActivity, ()>,
2092		aws_smithy_http::operation::BuildError,
2093	> {
2094		let mut request = {
2095			fn uri_base(
2096				_input: &crate::input::RemoveIdentityGameActivityInput,
2097				output: &mut String,
2098			) -> Result<(), aws_smithy_http::operation::BuildError> {
2099				write!(output, "/identities/self/activity").expect("formatting should succeed");
2100				Ok(())
2101			}
2102			#[allow(clippy::unnecessary_wraps)]
2103			fn update_http_builder(
2104				input: &crate::input::RemoveIdentityGameActivityInput,
2105				_config: &crate::config::Config,
2106				builder: http::request::Builder,
2107			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
2108			{
2109				let mut _uri = String::new();
2110				_uri = format!("{}{}", _config.uri.clone(), _uri);
2111				uri_base(input, &mut _uri)?;
2112				Ok(builder.method("DELETE").uri(_uri))
2113			}
2114			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
2115			let mut builder = if let Some(auth) = &_config.auth {
2116				builder.header(http::header::AUTHORIZATION, auth.clone())
2117			} else {
2118				builder
2119			};
2120			builder
2121		};
2122		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
2123		#[allow(clippy::useless_conversion)]
2124		let body = aws_smithy_http::body::SdkBody::from("");
2125		let request = request.body(body).expect("should be valid request");
2126		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
2127		request
2128			.properties_mut()
2129			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
2130		let op = aws_smithy_http::operation::Operation::new(
2131			request,
2132			crate::operation::RemoveIdentityGameActivity::new(),
2133		)
2134		.with_metadata(aws_smithy_http::operation::Metadata::new(
2135			"RemoveIdentityGameActivity",
2136			"IdentityService",
2137		));
2138		Ok(op)
2139	}
2140	/// Creates a new builder-style object to manufacture [`RemoveIdentityGameActivityInput`](crate::input::RemoveIdentityGameActivityInput)
2141	pub fn builder() -> crate::input::remove_identity_game_activity_input::Builder {
2142		crate::input::remove_identity_game_activity_input::Builder::default()
2143	}
2144}
2145
2146/// See [`ReportIdentityInput`](crate::input::ReportIdentityInput)
2147pub mod report_identity_input {
2148	/// A builder for [`ReportIdentityInput`](crate::input::ReportIdentityInput)
2149	#[non_exhaustive]
2150	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
2151	pub struct Builder {
2152		pub(crate) identity_id: std::option::Option<std::string::String>,
2153		pub(crate) reason: std::option::Option<std::string::String>,
2154	}
2155	impl Builder {
2156		/// A universally unique identifier.
2157		pub fn identity_id(mut self, input: impl Into<std::string::String>) -> Self {
2158			self.identity_id = Some(input.into());
2159			self
2160		}
2161		/// A universally unique identifier.
2162		pub fn set_identity_id(mut self, input: std::option::Option<std::string::String>) -> Self {
2163			self.identity_id = input;
2164			self
2165		}
2166		#[allow(missing_docs)] // documentation missing in model
2167		pub fn reason(mut self, input: impl Into<std::string::String>) -> Self {
2168			self.reason = Some(input.into());
2169			self
2170		}
2171		#[allow(missing_docs)] // documentation missing in model
2172		pub fn set_reason(mut self, input: std::option::Option<std::string::String>) -> Self {
2173			self.reason = input;
2174			self
2175		}
2176		/// Consumes the builder and constructs a [`ReportIdentityInput`](crate::input::ReportIdentityInput)
2177		pub fn build(
2178			self,
2179		) -> std::result::Result<
2180			crate::input::ReportIdentityInput,
2181			aws_smithy_http::operation::BuildError,
2182		> {
2183			Ok(crate::input::ReportIdentityInput {
2184				identity_id: self.identity_id,
2185				reason: self.reason,
2186			})
2187		}
2188	}
2189}
2190#[doc(hidden)]
2191pub type ReportIdentityInputOperationOutputAlias = crate::operation::ReportIdentity;
2192#[doc(hidden)]
2193pub type ReportIdentityInputOperationRetryAlias = ();
2194impl ReportIdentityInput {
2195	/// Consumes the builder and constructs an Operation<[`ReportIdentity`](crate::operation::ReportIdentity)>
2196	#[allow(unused_mut)]
2197	#[allow(clippy::let_and_return)]
2198	#[allow(clippy::needless_borrow)]
2199	pub async fn make_operation(
2200		&self,
2201		_config: &crate::config::Config,
2202	) -> std::result::Result<
2203		aws_smithy_http::operation::Operation<crate::operation::ReportIdentity, ()>,
2204		aws_smithy_http::operation::BuildError,
2205	> {
2206		let mut request = {
2207			fn uri_base(
2208				_input: &crate::input::ReportIdentityInput,
2209				output: &mut String,
2210			) -> Result<(), aws_smithy_http::operation::BuildError> {
2211				let input_24 = &_input.identity_id;
2212				let input_24 = input_24.as_ref().ok_or(
2213					aws_smithy_http::operation::BuildError::MissingField {
2214						field: "identity_id",
2215						details: "cannot be empty or unset",
2216					},
2217				)?;
2218				let identity_id = aws_smithy_http::label::fmt_string(input_24, false);
2219				if identity_id.is_empty() {
2220					return Err(aws_smithy_http::operation::BuildError::MissingField {
2221						field: "identity_id",
2222						details: "cannot be empty or unset",
2223					});
2224				}
2225				write!(
2226					output,
2227					"/identities/{identity_id}/report",
2228					identity_id = identity_id
2229				)
2230				.expect("formatting should succeed");
2231				Ok(())
2232			}
2233			#[allow(clippy::unnecessary_wraps)]
2234			fn update_http_builder(
2235				input: &crate::input::ReportIdentityInput,
2236				_config: &crate::config::Config,
2237				builder: http::request::Builder,
2238			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
2239			{
2240				let mut _uri = String::new();
2241				_uri = format!("{}{}", _config.uri.clone(), _uri);
2242				uri_base(input, &mut _uri)?;
2243				Ok(builder.method("POST").uri(_uri))
2244			}
2245			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
2246			let mut builder = if let Some(auth) = &_config.auth {
2247				builder.header(http::header::AUTHORIZATION, auth.clone())
2248			} else {
2249				builder
2250			};
2251			builder = aws_smithy_http::header::set_request_header_if_absent(
2252				builder,
2253				http::header::CONTENT_TYPE,
2254				"application/json",
2255			);
2256			builder
2257		};
2258		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
2259		#[allow(clippy::useless_conversion)]
2260		let body = aws_smithy_http::body::SdkBody::from(
2261			crate::operation_ser::serialize_operation_crate_operation_report_identity(&self)?,
2262		);
2263		if let Some(content_length) = body.content_length() {
2264			request = aws_smithy_http::header::set_request_header_if_absent(
2265				request,
2266				http::header::CONTENT_LENGTH,
2267				content_length,
2268			);
2269		}
2270		let request = request.body(body).expect("should be valid request");
2271		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
2272		request
2273			.properties_mut()
2274			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
2275		let op = aws_smithy_http::operation::Operation::new(
2276			request,
2277			crate::operation::ReportIdentity::new(),
2278		)
2279		.with_metadata(aws_smithy_http::operation::Metadata::new(
2280			"ReportIdentity",
2281			"IdentityService",
2282		));
2283		Ok(op)
2284	}
2285	/// Creates a new builder-style object to manufacture [`ReportIdentityInput`](crate::input::ReportIdentityInput)
2286	pub fn builder() -> crate::input::report_identity_input::Builder {
2287		crate::input::report_identity_input::Builder::default()
2288	}
2289}
2290
2291/// See [`SearchIdentitiesInput`](crate::input::SearchIdentitiesInput)
2292pub mod search_identities_input {
2293	/// A builder for [`SearchIdentitiesInput`](crate::input::SearchIdentitiesInput)
2294	#[non_exhaustive]
2295	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
2296	pub struct Builder {
2297		pub(crate) query: std::option::Option<std::string::String>,
2298		pub(crate) anchor: std::option::Option<std::string::String>,
2299		pub(crate) limit: std::option::Option<i32>,
2300	}
2301	impl Builder {
2302		/// The query to match identity display names and account numbers against.
2303		pub fn query(mut self, input: impl Into<std::string::String>) -> Self {
2304			self.query = Some(input.into());
2305			self
2306		}
2307		/// The query to match identity display names and account numbers against.
2308		pub fn set_query(mut self, input: std::option::Option<std::string::String>) -> Self {
2309			self.query = input;
2310			self
2311		}
2312		/// How many identities to offset the search by.
2313		pub fn anchor(mut self, input: impl Into<std::string::String>) -> Self {
2314			self.anchor = Some(input.into());
2315			self
2316		}
2317		/// How many identities to offset the search by.
2318		pub fn set_anchor(mut self, input: std::option::Option<std::string::String>) -> Self {
2319			self.anchor = input;
2320			self
2321		}
2322		/// Amount of identities to return.
2323		pub fn limit(mut self, input: i32) -> Self {
2324			self.limit = Some(input);
2325			self
2326		}
2327		/// Amount of identities to return.
2328		pub fn set_limit(mut self, input: std::option::Option<i32>) -> Self {
2329			self.limit = input;
2330			self
2331		}
2332		/// Consumes the builder and constructs a [`SearchIdentitiesInput`](crate::input::SearchIdentitiesInput)
2333		pub fn build(
2334			self,
2335		) -> std::result::Result<
2336			crate::input::SearchIdentitiesInput,
2337			aws_smithy_http::operation::BuildError,
2338		> {
2339			Ok(crate::input::SearchIdentitiesInput {
2340				query: self.query,
2341				anchor: self.anchor,
2342				limit: self.limit,
2343			})
2344		}
2345	}
2346}
2347#[doc(hidden)]
2348pub type SearchIdentitiesInputOperationOutputAlias = crate::operation::SearchIdentities;
2349#[doc(hidden)]
2350pub type SearchIdentitiesInputOperationRetryAlias = ();
2351impl SearchIdentitiesInput {
2352	/// Consumes the builder and constructs an Operation<[`SearchIdentities`](crate::operation::SearchIdentities)>
2353	#[allow(unused_mut)]
2354	#[allow(clippy::let_and_return)]
2355	#[allow(clippy::needless_borrow)]
2356	pub async fn make_operation(
2357		&self,
2358		_config: &crate::config::Config,
2359	) -> std::result::Result<
2360		aws_smithy_http::operation::Operation<crate::operation::SearchIdentities, ()>,
2361		aws_smithy_http::operation::BuildError,
2362	> {
2363		let mut request = {
2364			fn uri_base(
2365				_input: &crate::input::SearchIdentitiesInput,
2366				output: &mut String,
2367			) -> Result<(), aws_smithy_http::operation::BuildError> {
2368				write!(output, "/identities/search").expect("formatting should succeed");
2369				Ok(())
2370			}
2371			fn uri_query(
2372				_input: &crate::input::SearchIdentitiesInput,
2373				mut output: &mut String,
2374			) -> Result<(), aws_smithy_http::operation::BuildError> {
2375				let mut query = aws_smithy_http::query::Writer::new(&mut output);
2376				if let Some(inner_25) = &_input.query {
2377					query.push_kv("query", &aws_smithy_http::query::fmt_string(&inner_25));
2378				}
2379				if let Some(inner_26) = &_input.anchor {
2380					query.push_kv("anchor", &aws_smithy_http::query::fmt_string(&inner_26));
2381				}
2382				if let Some(inner_27) = &_input.limit {
2383					query.push_kv(
2384						"limit",
2385						aws_smithy_types::primitive::Encoder::from(*inner_27).encode(),
2386					);
2387				}
2388				Ok(())
2389			}
2390			#[allow(clippy::unnecessary_wraps)]
2391			fn update_http_builder(
2392				input: &crate::input::SearchIdentitiesInput,
2393				_config: &crate::config::Config,
2394				builder: http::request::Builder,
2395			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
2396			{
2397				let mut _uri = String::new();
2398				_uri = format!("{}{}", _config.uri.clone(), _uri);
2399				uri_base(input, &mut _uri)?;
2400				uri_query(input, &mut _uri)?;
2401				Ok(builder.method("GET").uri(_uri))
2402			}
2403			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
2404			let mut builder = if let Some(auth) = &_config.auth {
2405				builder.header(http::header::AUTHORIZATION, auth.clone())
2406			} else {
2407				builder
2408			};
2409			builder
2410		};
2411		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
2412		#[allow(clippy::useless_conversion)]
2413		let body = aws_smithy_http::body::SdkBody::from("");
2414		let request = request.body(body).expect("should be valid request");
2415		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
2416		request
2417			.properties_mut()
2418			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
2419		let op = aws_smithy_http::operation::Operation::new(
2420			request,
2421			crate::operation::SearchIdentities::new(),
2422		)
2423		.with_metadata(aws_smithy_http::operation::Metadata::new(
2424			"SearchIdentities",
2425			"IdentityService",
2426		));
2427		Ok(op)
2428	}
2429	/// Creates a new builder-style object to manufacture [`SearchIdentitiesInput`](crate::input::SearchIdentitiesInput)
2430	pub fn builder() -> crate::input::search_identities_input::Builder {
2431		crate::input::search_identities_input::Builder::default()
2432	}
2433}
2434
2435/// See [`SetIdentityGameActivityInput`](crate::input::SetIdentityGameActivityInput)
2436pub mod set_identity_game_activity_input {
2437	/// A builder for [`SetIdentityGameActivityInput`](crate::input::SetIdentityGameActivityInput)
2438	#[non_exhaustive]
2439	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
2440	pub struct Builder {
2441		pub(crate) game_activity: std::option::Option<crate::model::UpdateIdentityGameActivity>,
2442	}
2443	impl Builder {
2444		/// Information about the identity's current game. This is information that all other identities can see about what the current identity is doing.
2445		pub fn game_activity(mut self, input: crate::model::UpdateIdentityGameActivity) -> Self {
2446			self.game_activity = Some(input);
2447			self
2448		}
2449		/// Information about the identity's current game. This is information that all other identities can see about what the current identity is doing.
2450		pub fn set_game_activity(
2451			mut self,
2452			input: std::option::Option<crate::model::UpdateIdentityGameActivity>,
2453		) -> Self {
2454			self.game_activity = input;
2455			self
2456		}
2457		/// Consumes the builder and constructs a [`SetIdentityGameActivityInput`](crate::input::SetIdentityGameActivityInput)
2458		pub fn build(
2459			self,
2460		) -> std::result::Result<
2461			crate::input::SetIdentityGameActivityInput,
2462			aws_smithy_http::operation::BuildError,
2463		> {
2464			Ok(crate::input::SetIdentityGameActivityInput {
2465				game_activity: self.game_activity,
2466			})
2467		}
2468	}
2469}
2470#[doc(hidden)]
2471pub type SetIdentityGameActivityInputOperationOutputAlias =
2472	crate::operation::SetIdentityGameActivity;
2473#[doc(hidden)]
2474pub type SetIdentityGameActivityInputOperationRetryAlias = ();
2475impl SetIdentityGameActivityInput {
2476	/// Consumes the builder and constructs an Operation<[`SetIdentityGameActivity`](crate::operation::SetIdentityGameActivity)>
2477	#[allow(unused_mut)]
2478	#[allow(clippy::let_and_return)]
2479	#[allow(clippy::needless_borrow)]
2480	pub async fn make_operation(
2481		&self,
2482		_config: &crate::config::Config,
2483	) -> std::result::Result<
2484		aws_smithy_http::operation::Operation<crate::operation::SetIdentityGameActivity, ()>,
2485		aws_smithy_http::operation::BuildError,
2486	> {
2487		let mut request = {
2488			fn uri_base(
2489				_input: &crate::input::SetIdentityGameActivityInput,
2490				output: &mut String,
2491			) -> Result<(), aws_smithy_http::operation::BuildError> {
2492				write!(output, "/identities/self/activity").expect("formatting should succeed");
2493				Ok(())
2494			}
2495			#[allow(clippy::unnecessary_wraps)]
2496			fn update_http_builder(
2497				input: &crate::input::SetIdentityGameActivityInput,
2498				_config: &crate::config::Config,
2499				builder: http::request::Builder,
2500			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
2501			{
2502				let mut _uri = String::new();
2503				_uri = format!("{}{}", _config.uri.clone(), _uri);
2504				uri_base(input, &mut _uri)?;
2505				Ok(builder.method("POST").uri(_uri))
2506			}
2507			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
2508			let mut builder = if let Some(auth) = &_config.auth {
2509				builder.header(http::header::AUTHORIZATION, auth.clone())
2510			} else {
2511				builder
2512			};
2513			builder = aws_smithy_http::header::set_request_header_if_absent(
2514				builder,
2515				http::header::CONTENT_TYPE,
2516				"application/json",
2517			);
2518			builder
2519		};
2520		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
2521		#[allow(clippy::useless_conversion)]
2522		let body = aws_smithy_http::body::SdkBody::from(
2523			crate::operation_ser::serialize_operation_crate_operation_set_identity_game_activity(
2524				&self,
2525			)?,
2526		);
2527		if let Some(content_length) = body.content_length() {
2528			request = aws_smithy_http::header::set_request_header_if_absent(
2529				request,
2530				http::header::CONTENT_LENGTH,
2531				content_length,
2532			);
2533		}
2534		let request = request.body(body).expect("should be valid request");
2535		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
2536		request
2537			.properties_mut()
2538			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
2539		let op = aws_smithy_http::operation::Operation::new(
2540			request,
2541			crate::operation::SetIdentityGameActivity::new(),
2542		)
2543		.with_metadata(aws_smithy_http::operation::Metadata::new(
2544			"SetIdentityGameActivity",
2545			"IdentityService",
2546		));
2547		Ok(op)
2548	}
2549	/// Creates a new builder-style object to manufacture [`SetIdentityGameActivityInput`](crate::input::SetIdentityGameActivityInput)
2550	pub fn builder() -> crate::input::set_identity_game_activity_input::Builder {
2551		crate::input::set_identity_game_activity_input::Builder::default()
2552	}
2553}
2554
2555/// See [`SetupIdentityInput`](crate::input::SetupIdentityInput)
2556pub mod setup_identity_input {
2557	/// A builder for [`SetupIdentityInput`](crate::input::SetupIdentityInput)
2558	#[non_exhaustive]
2559	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
2560	pub struct Builder {
2561		pub(crate) existing_identity_token: std::option::Option<std::string::String>,
2562	}
2563	impl Builder {
2564		/// Token returned from previous call to `rivet.api.identity#SetupIdentity`. If this token is invalid, a new identity will be returned.
2565		pub fn existing_identity_token(mut self, input: impl Into<std::string::String>) -> Self {
2566			self.existing_identity_token = Some(input.into());
2567			self
2568		}
2569		/// Token returned from previous call to `rivet.api.identity#SetupIdentity`. If this token is invalid, a new identity will be returned.
2570		pub fn set_existing_identity_token(
2571			mut self,
2572			input: std::option::Option<std::string::String>,
2573		) -> Self {
2574			self.existing_identity_token = input;
2575			self
2576		}
2577		/// Consumes the builder and constructs a [`SetupIdentityInput`](crate::input::SetupIdentityInput)
2578		pub fn build(
2579			self,
2580		) -> std::result::Result<
2581			crate::input::SetupIdentityInput,
2582			aws_smithy_http::operation::BuildError,
2583		> {
2584			Ok(crate::input::SetupIdentityInput {
2585				existing_identity_token: self.existing_identity_token,
2586			})
2587		}
2588	}
2589}
2590#[doc(hidden)]
2591pub type SetupIdentityInputOperationOutputAlias = crate::operation::SetupIdentity;
2592#[doc(hidden)]
2593pub type SetupIdentityInputOperationRetryAlias = ();
2594impl SetupIdentityInput {
2595	/// Consumes the builder and constructs an Operation<[`SetupIdentity`](crate::operation::SetupIdentity)>
2596	#[allow(unused_mut)]
2597	#[allow(clippy::let_and_return)]
2598	#[allow(clippy::needless_borrow)]
2599	pub async fn make_operation(
2600		&self,
2601		_config: &crate::config::Config,
2602	) -> std::result::Result<
2603		aws_smithy_http::operation::Operation<crate::operation::SetupIdentity, ()>,
2604		aws_smithy_http::operation::BuildError,
2605	> {
2606		let mut request = {
2607			fn uri_base(
2608				_input: &crate::input::SetupIdentityInput,
2609				output: &mut String,
2610			) -> Result<(), aws_smithy_http::operation::BuildError> {
2611				write!(output, "/identities").expect("formatting should succeed");
2612				Ok(())
2613			}
2614			#[allow(clippy::unnecessary_wraps)]
2615			fn update_http_builder(
2616				input: &crate::input::SetupIdentityInput,
2617				_config: &crate::config::Config,
2618				builder: http::request::Builder,
2619			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
2620			{
2621				let mut _uri = String::new();
2622				_uri = format!("{}{}", _config.uri.clone(), _uri);
2623				uri_base(input, &mut _uri)?;
2624				Ok(builder.method("POST").uri(_uri))
2625			}
2626			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
2627			let mut builder = if let Some(auth) = &_config.auth {
2628				builder.header(http::header::AUTHORIZATION, auth.clone())
2629			} else {
2630				builder
2631			};
2632			builder = aws_smithy_http::header::set_request_header_if_absent(
2633				builder,
2634				http::header::CONTENT_TYPE,
2635				"application/json",
2636			);
2637			builder
2638		};
2639		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
2640		#[allow(clippy::useless_conversion)]
2641		let body = aws_smithy_http::body::SdkBody::from(
2642			crate::operation_ser::serialize_operation_crate_operation_setup_identity(&self)?,
2643		);
2644		if let Some(content_length) = body.content_length() {
2645			request = aws_smithy_http::header::set_request_header_if_absent(
2646				request,
2647				http::header::CONTENT_LENGTH,
2648				content_length,
2649			);
2650		}
2651		let request = request.body(body).expect("should be valid request");
2652		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
2653		request
2654			.properties_mut()
2655			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
2656		let op = aws_smithy_http::operation::Operation::new(
2657			request,
2658			crate::operation::SetupIdentity::new(),
2659		)
2660		.with_metadata(aws_smithy_http::operation::Metadata::new(
2661			"SetupIdentity",
2662			"IdentityService",
2663		));
2664		Ok(op)
2665	}
2666	/// Creates a new builder-style object to manufacture [`SetupIdentityInput`](crate::input::SetupIdentityInput)
2667	pub fn builder() -> crate::input::setup_identity_input::Builder {
2668		crate::input::setup_identity_input::Builder::default()
2669	}
2670}
2671
2672/// See [`SignupForBetaInput`](crate::input::SignupForBetaInput)
2673pub mod signup_for_beta_input {
2674	/// A builder for [`SignupForBetaInput`](crate::input::SignupForBetaInput)
2675	#[non_exhaustive]
2676	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
2677	pub struct Builder {
2678		pub(crate) name: std::option::Option<std::string::String>,
2679		pub(crate) company_name: std::option::Option<std::string::String>,
2680		pub(crate) company_size: std::option::Option<std::string::String>,
2681		pub(crate) preferred_tools: std::option::Option<std::string::String>,
2682		pub(crate) goals: std::option::Option<std::string::String>,
2683	}
2684	impl Builder {
2685		#[allow(missing_docs)] // documentation missing in model
2686		pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
2687			self.name = Some(input.into());
2688			self
2689		}
2690		#[allow(missing_docs)] // documentation missing in model
2691		pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
2692			self.name = input;
2693			self
2694		}
2695		#[allow(missing_docs)] // documentation missing in model
2696		pub fn company_name(mut self, input: impl Into<std::string::String>) -> Self {
2697			self.company_name = Some(input.into());
2698			self
2699		}
2700		#[allow(missing_docs)] // documentation missing in model
2701		pub fn set_company_name(mut self, input: std::option::Option<std::string::String>) -> Self {
2702			self.company_name = input;
2703			self
2704		}
2705		#[allow(missing_docs)] // documentation missing in model
2706		pub fn company_size(mut self, input: impl Into<std::string::String>) -> Self {
2707			self.company_size = Some(input.into());
2708			self
2709		}
2710		#[allow(missing_docs)] // documentation missing in model
2711		pub fn set_company_size(mut self, input: std::option::Option<std::string::String>) -> Self {
2712			self.company_size = input;
2713			self
2714		}
2715		#[allow(missing_docs)] // documentation missing in model
2716		pub fn preferred_tools(mut self, input: impl Into<std::string::String>) -> Self {
2717			self.preferred_tools = Some(input.into());
2718			self
2719		}
2720		#[allow(missing_docs)] // documentation missing in model
2721		pub fn set_preferred_tools(
2722			mut self,
2723			input: std::option::Option<std::string::String>,
2724		) -> Self {
2725			self.preferred_tools = input;
2726			self
2727		}
2728		#[allow(missing_docs)] // documentation missing in model
2729		pub fn goals(mut self, input: impl Into<std::string::String>) -> Self {
2730			self.goals = Some(input.into());
2731			self
2732		}
2733		#[allow(missing_docs)] // documentation missing in model
2734		pub fn set_goals(mut self, input: std::option::Option<std::string::String>) -> Self {
2735			self.goals = input;
2736			self
2737		}
2738		/// Consumes the builder and constructs a [`SignupForBetaInput`](crate::input::SignupForBetaInput)
2739		pub fn build(
2740			self,
2741		) -> std::result::Result<
2742			crate::input::SignupForBetaInput,
2743			aws_smithy_http::operation::BuildError,
2744		> {
2745			Ok(crate::input::SignupForBetaInput {
2746				name: self.name,
2747				company_name: self.company_name,
2748				company_size: self.company_size,
2749				preferred_tools: self.preferred_tools,
2750				goals: self.goals,
2751			})
2752		}
2753	}
2754}
2755#[doc(hidden)]
2756pub type SignupForBetaInputOperationOutputAlias = crate::operation::SignupForBeta;
2757#[doc(hidden)]
2758pub type SignupForBetaInputOperationRetryAlias = ();
2759impl SignupForBetaInput {
2760	/// Consumes the builder and constructs an Operation<[`SignupForBeta`](crate::operation::SignupForBeta)>
2761	#[allow(unused_mut)]
2762	#[allow(clippy::let_and_return)]
2763	#[allow(clippy::needless_borrow)]
2764	pub async fn make_operation(
2765		&self,
2766		_config: &crate::config::Config,
2767	) -> std::result::Result<
2768		aws_smithy_http::operation::Operation<crate::operation::SignupForBeta, ()>,
2769		aws_smithy_http::operation::BuildError,
2770	> {
2771		let mut request = {
2772			fn uri_base(
2773				_input: &crate::input::SignupForBetaInput,
2774				output: &mut String,
2775			) -> Result<(), aws_smithy_http::operation::BuildError> {
2776				write!(output, "/identities/self/beta-signup").expect("formatting should succeed");
2777				Ok(())
2778			}
2779			#[allow(clippy::unnecessary_wraps)]
2780			fn update_http_builder(
2781				input: &crate::input::SignupForBetaInput,
2782				_config: &crate::config::Config,
2783				builder: http::request::Builder,
2784			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
2785			{
2786				let mut _uri = String::new();
2787				_uri = format!("{}{}", _config.uri.clone(), _uri);
2788				uri_base(input, &mut _uri)?;
2789				Ok(builder.method("POST").uri(_uri))
2790			}
2791			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
2792			let mut builder = if let Some(auth) = &_config.auth {
2793				builder.header(http::header::AUTHORIZATION, auth.clone())
2794			} else {
2795				builder
2796			};
2797			builder = aws_smithy_http::header::set_request_header_if_absent(
2798				builder,
2799				http::header::CONTENT_TYPE,
2800				"application/json",
2801			);
2802			builder
2803		};
2804		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
2805		#[allow(clippy::useless_conversion)]
2806		let body = aws_smithy_http::body::SdkBody::from(
2807			crate::operation_ser::serialize_operation_crate_operation_signup_for_beta(&self)?,
2808		);
2809		if let Some(content_length) = body.content_length() {
2810			request = aws_smithy_http::header::set_request_header_if_absent(
2811				request,
2812				http::header::CONTENT_LENGTH,
2813				content_length,
2814			);
2815		}
2816		let request = request.body(body).expect("should be valid request");
2817		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
2818		request
2819			.properties_mut()
2820			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
2821		let op = aws_smithy_http::operation::Operation::new(
2822			request,
2823			crate::operation::SignupForBeta::new(),
2824		)
2825		.with_metadata(aws_smithy_http::operation::Metadata::new(
2826			"SignupForBeta",
2827			"IdentityService",
2828		));
2829		Ok(op)
2830	}
2831	/// Creates a new builder-style object to manufacture [`SignupForBetaInput`](crate::input::SignupForBetaInput)
2832	pub fn builder() -> crate::input::signup_for_beta_input::Builder {
2833		crate::input::signup_for_beta_input::Builder::default()
2834	}
2835}
2836
2837/// See [`UnfollowIdentityInput`](crate::input::UnfollowIdentityInput)
2838pub mod unfollow_identity_input {
2839	/// A builder for [`UnfollowIdentityInput`](crate::input::UnfollowIdentityInput)
2840	#[non_exhaustive]
2841	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
2842	pub struct Builder {
2843		pub(crate) identity_id: std::option::Option<std::string::String>,
2844	}
2845	impl Builder {
2846		/// A universally unique identifier.
2847		pub fn identity_id(mut self, input: impl Into<std::string::String>) -> Self {
2848			self.identity_id = Some(input.into());
2849			self
2850		}
2851		/// A universally unique identifier.
2852		pub fn set_identity_id(mut self, input: std::option::Option<std::string::String>) -> Self {
2853			self.identity_id = input;
2854			self
2855		}
2856		/// Consumes the builder and constructs a [`UnfollowIdentityInput`](crate::input::UnfollowIdentityInput)
2857		pub fn build(
2858			self,
2859		) -> std::result::Result<
2860			crate::input::UnfollowIdentityInput,
2861			aws_smithy_http::operation::BuildError,
2862		> {
2863			Ok(crate::input::UnfollowIdentityInput {
2864				identity_id: self.identity_id,
2865			})
2866		}
2867	}
2868}
2869#[doc(hidden)]
2870pub type UnfollowIdentityInputOperationOutputAlias = crate::operation::UnfollowIdentity;
2871#[doc(hidden)]
2872pub type UnfollowIdentityInputOperationRetryAlias = ();
2873impl UnfollowIdentityInput {
2874	/// Consumes the builder and constructs an Operation<[`UnfollowIdentity`](crate::operation::UnfollowIdentity)>
2875	#[allow(unused_mut)]
2876	#[allow(clippy::let_and_return)]
2877	#[allow(clippy::needless_borrow)]
2878	pub async fn make_operation(
2879		&self,
2880		_config: &crate::config::Config,
2881	) -> std::result::Result<
2882		aws_smithy_http::operation::Operation<crate::operation::UnfollowIdentity, ()>,
2883		aws_smithy_http::operation::BuildError,
2884	> {
2885		let mut request = {
2886			fn uri_base(
2887				_input: &crate::input::UnfollowIdentityInput,
2888				output: &mut String,
2889			) -> Result<(), aws_smithy_http::operation::BuildError> {
2890				let input_28 = &_input.identity_id;
2891				let input_28 = input_28.as_ref().ok_or(
2892					aws_smithy_http::operation::BuildError::MissingField {
2893						field: "identity_id",
2894						details: "cannot be empty or unset",
2895					},
2896				)?;
2897				let identity_id = aws_smithy_http::label::fmt_string(input_28, false);
2898				if identity_id.is_empty() {
2899					return Err(aws_smithy_http::operation::BuildError::MissingField {
2900						field: "identity_id",
2901						details: "cannot be empty or unset",
2902					});
2903				}
2904				write!(
2905					output,
2906					"/identities/{identity_id}/follow",
2907					identity_id = identity_id
2908				)
2909				.expect("formatting should succeed");
2910				Ok(())
2911			}
2912			#[allow(clippy::unnecessary_wraps)]
2913			fn update_http_builder(
2914				input: &crate::input::UnfollowIdentityInput,
2915				_config: &crate::config::Config,
2916				builder: http::request::Builder,
2917			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
2918			{
2919				let mut _uri = String::new();
2920				_uri = format!("{}{}", _config.uri.clone(), _uri);
2921				uri_base(input, &mut _uri)?;
2922				Ok(builder.method("DELETE").uri(_uri))
2923			}
2924			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
2925			let mut builder = if let Some(auth) = &_config.auth {
2926				builder.header(http::header::AUTHORIZATION, auth.clone())
2927			} else {
2928				builder
2929			};
2930			builder
2931		};
2932		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
2933		#[allow(clippy::useless_conversion)]
2934		let body = aws_smithy_http::body::SdkBody::from("");
2935		let request = request.body(body).expect("should be valid request");
2936		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
2937		request
2938			.properties_mut()
2939			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
2940		let op = aws_smithy_http::operation::Operation::new(
2941			request,
2942			crate::operation::UnfollowIdentity::new(),
2943		)
2944		.with_metadata(aws_smithy_http::operation::Metadata::new(
2945			"UnfollowIdentity",
2946			"IdentityService",
2947		));
2948		Ok(op)
2949	}
2950	/// Creates a new builder-style object to manufacture [`UnfollowIdentityInput`](crate::input::UnfollowIdentityInput)
2951	pub fn builder() -> crate::input::unfollow_identity_input::Builder {
2952		crate::input::unfollow_identity_input::Builder::default()
2953	}
2954}
2955
2956/// See [`UpdateIdentityProfileInput`](crate::input::UpdateIdentityProfileInput)
2957pub mod update_identity_profile_input {
2958	/// A builder for [`UpdateIdentityProfileInput`](crate::input::UpdateIdentityProfileInput)
2959	#[non_exhaustive]
2960	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
2961	pub struct Builder {
2962		pub(crate) display_name: std::option::Option<std::string::String>,
2963		pub(crate) account_number: std::option::Option<i32>,
2964		pub(crate) bio: std::option::Option<std::string::String>,
2965	}
2966	impl Builder {
2967		/// Represent a resource's readable display name.
2968		pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
2969			self.display_name = Some(input.into());
2970			self
2971		}
2972		/// Represent a resource's readable display name.
2973		pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
2974			self.display_name = input;
2975			self
2976		}
2977		/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
2978		pub fn account_number(mut self, input: i32) -> Self {
2979			self.account_number = Some(input);
2980			self
2981		}
2982		/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
2983		pub fn set_account_number(mut self, input: std::option::Option<i32>) -> Self {
2984			self.account_number = input;
2985			self
2986		}
2987		/// Detailed information about a profile.
2988		pub fn bio(mut self, input: impl Into<std::string::String>) -> Self {
2989			self.bio = Some(input.into());
2990			self
2991		}
2992		/// Detailed information about a profile.
2993		pub fn set_bio(mut self, input: std::option::Option<std::string::String>) -> Self {
2994			self.bio = input;
2995			self
2996		}
2997		/// Consumes the builder and constructs a [`UpdateIdentityProfileInput`](crate::input::UpdateIdentityProfileInput)
2998		pub fn build(
2999			self,
3000		) -> std::result::Result<
3001			crate::input::UpdateIdentityProfileInput,
3002			aws_smithy_http::operation::BuildError,
3003		> {
3004			Ok(crate::input::UpdateIdentityProfileInput {
3005				display_name: self.display_name,
3006				account_number: self.account_number,
3007				bio: self.bio,
3008			})
3009		}
3010	}
3011}
3012#[doc(hidden)]
3013pub type UpdateIdentityProfileInputOperationOutputAlias = crate::operation::UpdateIdentityProfile;
3014#[doc(hidden)]
3015pub type UpdateIdentityProfileInputOperationRetryAlias = ();
3016impl UpdateIdentityProfileInput {
3017	/// Consumes the builder and constructs an Operation<[`UpdateIdentityProfile`](crate::operation::UpdateIdentityProfile)>
3018	#[allow(unused_mut)]
3019	#[allow(clippy::let_and_return)]
3020	#[allow(clippy::needless_borrow)]
3021	pub async fn make_operation(
3022		&self,
3023		_config: &crate::config::Config,
3024	) -> std::result::Result<
3025		aws_smithy_http::operation::Operation<crate::operation::UpdateIdentityProfile, ()>,
3026		aws_smithy_http::operation::BuildError,
3027	> {
3028		let mut request = {
3029			fn uri_base(
3030				_input: &crate::input::UpdateIdentityProfileInput,
3031				output: &mut String,
3032			) -> Result<(), aws_smithy_http::operation::BuildError> {
3033				write!(output, "/identities/self/profile").expect("formatting should succeed");
3034				Ok(())
3035			}
3036			#[allow(clippy::unnecessary_wraps)]
3037			fn update_http_builder(
3038				input: &crate::input::UpdateIdentityProfileInput,
3039				_config: &crate::config::Config,
3040				builder: http::request::Builder,
3041			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
3042			{
3043				let mut _uri = String::new();
3044				_uri = format!("{}{}", _config.uri.clone(), _uri);
3045				uri_base(input, &mut _uri)?;
3046				Ok(builder.method("POST").uri(_uri))
3047			}
3048			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
3049			let mut builder = if let Some(auth) = &_config.auth {
3050				builder.header(http::header::AUTHORIZATION, auth.clone())
3051			} else {
3052				builder
3053			};
3054			builder = aws_smithy_http::header::set_request_header_if_absent(
3055				builder,
3056				http::header::CONTENT_TYPE,
3057				"application/json",
3058			);
3059			builder
3060		};
3061		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
3062		#[allow(clippy::useless_conversion)]
3063		let body = aws_smithy_http::body::SdkBody::from(
3064			crate::operation_ser::serialize_operation_crate_operation_update_identity_profile(
3065				&self,
3066			)?,
3067		);
3068		if let Some(content_length) = body.content_length() {
3069			request = aws_smithy_http::header::set_request_header_if_absent(
3070				request,
3071				http::header::CONTENT_LENGTH,
3072				content_length,
3073			);
3074		}
3075		let request = request.body(body).expect("should be valid request");
3076		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
3077		request
3078			.properties_mut()
3079			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
3080		let op = aws_smithy_http::operation::Operation::new(
3081			request,
3082			crate::operation::UpdateIdentityProfile::new(),
3083		)
3084		.with_metadata(aws_smithy_http::operation::Metadata::new(
3085			"UpdateIdentityProfile",
3086			"IdentityService",
3087		));
3088		Ok(op)
3089	}
3090	/// Creates a new builder-style object to manufacture [`UpdateIdentityProfileInput`](crate::input::UpdateIdentityProfileInput)
3091	pub fn builder() -> crate::input::update_identity_profile_input::Builder {
3092		crate::input::update_identity_profile_input::Builder::default()
3093	}
3094}
3095
3096/// See [`UpdateIdentityStatusInput`](crate::input::UpdateIdentityStatusInput)
3097pub mod update_identity_status_input {
3098	/// A builder for [`UpdateIdentityStatusInput`](crate::input::UpdateIdentityStatusInput)
3099	#[non_exhaustive]
3100	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
3101	pub struct Builder {
3102		pub(crate) status: std::option::Option<crate::model::IdentityStatus>,
3103	}
3104	impl Builder {
3105		/// The current status of an identity. This helps players understand if another player is currently playing or has their game in the background.
3106		pub fn status(mut self, input: crate::model::IdentityStatus) -> Self {
3107			self.status = Some(input);
3108			self
3109		}
3110		/// The current status of an identity. This helps players understand if another player is currently playing or has their game in the background.
3111		pub fn set_status(
3112			mut self,
3113			input: std::option::Option<crate::model::IdentityStatus>,
3114		) -> Self {
3115			self.status = input;
3116			self
3117		}
3118		/// Consumes the builder and constructs a [`UpdateIdentityStatusInput`](crate::input::UpdateIdentityStatusInput)
3119		pub fn build(
3120			self,
3121		) -> std::result::Result<
3122			crate::input::UpdateIdentityStatusInput,
3123			aws_smithy_http::operation::BuildError,
3124		> {
3125			Ok(crate::input::UpdateIdentityStatusInput {
3126				status: self.status,
3127			})
3128		}
3129	}
3130}
3131#[doc(hidden)]
3132pub type UpdateIdentityStatusInputOperationOutputAlias = crate::operation::UpdateIdentityStatus;
3133#[doc(hidden)]
3134pub type UpdateIdentityStatusInputOperationRetryAlias = ();
3135impl UpdateIdentityStatusInput {
3136	/// Consumes the builder and constructs an Operation<[`UpdateIdentityStatus`](crate::operation::UpdateIdentityStatus)>
3137	#[allow(unused_mut)]
3138	#[allow(clippy::let_and_return)]
3139	#[allow(clippy::needless_borrow)]
3140	pub async fn make_operation(
3141		&self,
3142		_config: &crate::config::Config,
3143	) -> std::result::Result<
3144		aws_smithy_http::operation::Operation<crate::operation::UpdateIdentityStatus, ()>,
3145		aws_smithy_http::operation::BuildError,
3146	> {
3147		let mut request = {
3148			fn uri_base(
3149				_input: &crate::input::UpdateIdentityStatusInput,
3150				output: &mut String,
3151			) -> Result<(), aws_smithy_http::operation::BuildError> {
3152				write!(output, "/identities/self/status").expect("formatting should succeed");
3153				Ok(())
3154			}
3155			#[allow(clippy::unnecessary_wraps)]
3156			fn update_http_builder(
3157				input: &crate::input::UpdateIdentityStatusInput,
3158				_config: &crate::config::Config,
3159				builder: http::request::Builder,
3160			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
3161			{
3162				let mut _uri = String::new();
3163				_uri = format!("{}{}", _config.uri.clone(), _uri);
3164				uri_base(input, &mut _uri)?;
3165				Ok(builder.method("POST").uri(_uri))
3166			}
3167			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
3168			let mut builder = if let Some(auth) = &_config.auth {
3169				builder.header(http::header::AUTHORIZATION, auth.clone())
3170			} else {
3171				builder
3172			};
3173			builder = aws_smithy_http::header::set_request_header_if_absent(
3174				builder,
3175				http::header::CONTENT_TYPE,
3176				"application/json",
3177			);
3178			builder
3179		};
3180		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
3181		#[allow(clippy::useless_conversion)]
3182		let body = aws_smithy_http::body::SdkBody::from(
3183			crate::operation_ser::serialize_operation_crate_operation_update_identity_status(
3184				&self,
3185			)?,
3186		);
3187		if let Some(content_length) = body.content_length() {
3188			request = aws_smithy_http::header::set_request_header_if_absent(
3189				request,
3190				http::header::CONTENT_LENGTH,
3191				content_length,
3192			);
3193		}
3194		let request = request.body(body).expect("should be valid request");
3195		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
3196		request
3197			.properties_mut()
3198			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
3199		let op = aws_smithy_http::operation::Operation::new(
3200			request,
3201			crate::operation::UpdateIdentityStatus::new(),
3202		)
3203		.with_metadata(aws_smithy_http::operation::Metadata::new(
3204			"UpdateIdentityStatus",
3205			"IdentityService",
3206		));
3207		Ok(op)
3208	}
3209	/// Creates a new builder-style object to manufacture [`UpdateIdentityStatusInput`](crate::input::UpdateIdentityStatusInput)
3210	pub fn builder() -> crate::input::update_identity_status_input::Builder {
3211		crate::input::update_identity_status_input::Builder::default()
3212	}
3213}
3214
3215/// See [`ValidateIdentityProfileInput`](crate::input::ValidateIdentityProfileInput)
3216pub mod validate_identity_profile_input {
3217	/// A builder for [`ValidateIdentityProfileInput`](crate::input::ValidateIdentityProfileInput)
3218	#[non_exhaustive]
3219	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
3220	pub struct Builder {
3221		pub(crate) display_name: std::option::Option<std::string::String>,
3222		pub(crate) account_number: std::option::Option<i32>,
3223		pub(crate) bio: std::option::Option<std::string::String>,
3224	}
3225	impl Builder {
3226		/// Represent a resource's readable display name.
3227		pub fn display_name(mut self, input: impl Into<std::string::String>) -> Self {
3228			self.display_name = Some(input.into());
3229			self
3230		}
3231		/// Represent a resource's readable display name.
3232		pub fn set_display_name(mut self, input: std::option::Option<std::string::String>) -> Self {
3233			self.display_name = input;
3234			self
3235		}
3236		/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
3237		pub fn account_number(mut self, input: i32) -> Self {
3238			self.account_number = Some(input);
3239			self
3240		}
3241		/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
3242		pub fn set_account_number(mut self, input: std::option::Option<i32>) -> Self {
3243			self.account_number = input;
3244			self
3245		}
3246		/// Detailed information about a profile.
3247		pub fn bio(mut self, input: impl Into<std::string::String>) -> Self {
3248			self.bio = Some(input.into());
3249			self
3250		}
3251		/// Detailed information about a profile.
3252		pub fn set_bio(mut self, input: std::option::Option<std::string::String>) -> Self {
3253			self.bio = input;
3254			self
3255		}
3256		/// Consumes the builder and constructs a [`ValidateIdentityProfileInput`](crate::input::ValidateIdentityProfileInput)
3257		pub fn build(
3258			self,
3259		) -> std::result::Result<
3260			crate::input::ValidateIdentityProfileInput,
3261			aws_smithy_http::operation::BuildError,
3262		> {
3263			Ok(crate::input::ValidateIdentityProfileInput {
3264				display_name: self.display_name,
3265				account_number: self.account_number,
3266				bio: self.bio,
3267			})
3268		}
3269	}
3270}
3271#[doc(hidden)]
3272pub type ValidateIdentityProfileInputOperationOutputAlias =
3273	crate::operation::ValidateIdentityProfile;
3274#[doc(hidden)]
3275pub type ValidateIdentityProfileInputOperationRetryAlias = ();
3276impl ValidateIdentityProfileInput {
3277	/// Consumes the builder and constructs an Operation<[`ValidateIdentityProfile`](crate::operation::ValidateIdentityProfile)>
3278	#[allow(unused_mut)]
3279	#[allow(clippy::let_and_return)]
3280	#[allow(clippy::needless_borrow)]
3281	pub async fn make_operation(
3282		&self,
3283		_config: &crate::config::Config,
3284	) -> std::result::Result<
3285		aws_smithy_http::operation::Operation<crate::operation::ValidateIdentityProfile, ()>,
3286		aws_smithy_http::operation::BuildError,
3287	> {
3288		let mut request = {
3289			fn uri_base(
3290				_input: &crate::input::ValidateIdentityProfileInput,
3291				output: &mut String,
3292			) -> Result<(), aws_smithy_http::operation::BuildError> {
3293				write!(output, "/identities/self/profile/validate")
3294					.expect("formatting should succeed");
3295				Ok(())
3296			}
3297			#[allow(clippy::unnecessary_wraps)]
3298			fn update_http_builder(
3299				input: &crate::input::ValidateIdentityProfileInput,
3300				_config: &crate::config::Config,
3301				builder: http::request::Builder,
3302			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
3303			{
3304				let mut _uri = String::new();
3305				_uri = format!("{}{}", _config.uri.clone(), _uri);
3306				uri_base(input, &mut _uri)?;
3307				Ok(builder.method("POST").uri(_uri))
3308			}
3309			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
3310			let mut builder = if let Some(auth) = &_config.auth {
3311				builder.header(http::header::AUTHORIZATION, auth.clone())
3312			} else {
3313				builder
3314			};
3315			builder = aws_smithy_http::header::set_request_header_if_absent(
3316				builder,
3317				http::header::CONTENT_TYPE,
3318				"application/json",
3319			);
3320			builder
3321		};
3322		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
3323		#[allow(clippy::useless_conversion)]
3324		let body = aws_smithy_http::body::SdkBody::from(
3325			crate::operation_ser::serialize_operation_crate_operation_validate_identity_profile(
3326				&self,
3327			)?,
3328		);
3329		if let Some(content_length) = body.content_length() {
3330			request = aws_smithy_http::header::set_request_header_if_absent(
3331				request,
3332				http::header::CONTENT_LENGTH,
3333				content_length,
3334			);
3335		}
3336		let request = request.body(body).expect("should be valid request");
3337		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
3338		request
3339			.properties_mut()
3340			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
3341		let op = aws_smithy_http::operation::Operation::new(
3342			request,
3343			crate::operation::ValidateIdentityProfile::new(),
3344		)
3345		.with_metadata(aws_smithy_http::operation::Metadata::new(
3346			"ValidateIdentityProfile",
3347			"IdentityService",
3348		));
3349		Ok(op)
3350	}
3351	/// Creates a new builder-style object to manufacture [`ValidateIdentityProfileInput`](crate::input::ValidateIdentityProfileInput)
3352	pub fn builder() -> crate::input::validate_identity_profile_input::Builder {
3353		crate::input::validate_identity_profile_input::Builder::default()
3354	}
3355}
3356
3357/// See [`WatchEventsInput`](crate::input::WatchEventsInput)
3358pub mod watch_events_input {
3359	/// A builder for [`WatchEventsInput`](crate::input::WatchEventsInput)
3360	#[non_exhaustive]
3361	#[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
3362	pub struct Builder {
3363		pub(crate) watch_index: std::option::Option<std::string::String>,
3364	}
3365	impl Builder {
3366		/// A query parameter denoting the requests watch index.
3367		pub fn watch_index(mut self, input: impl Into<std::string::String>) -> Self {
3368			self.watch_index = Some(input.into());
3369			self
3370		}
3371		/// A query parameter denoting the requests watch index.
3372		pub fn set_watch_index(mut self, input: std::option::Option<std::string::String>) -> Self {
3373			self.watch_index = input;
3374			self
3375		}
3376		/// Consumes the builder and constructs a [`WatchEventsInput`](crate::input::WatchEventsInput)
3377		pub fn build(
3378			self,
3379		) -> std::result::Result<
3380			crate::input::WatchEventsInput,
3381			aws_smithy_http::operation::BuildError,
3382		> {
3383			Ok(crate::input::WatchEventsInput {
3384				watch_index: self.watch_index,
3385			})
3386		}
3387	}
3388}
3389#[doc(hidden)]
3390pub type WatchEventsInputOperationOutputAlias = crate::operation::WatchEvents;
3391#[doc(hidden)]
3392pub type WatchEventsInputOperationRetryAlias = ();
3393impl WatchEventsInput {
3394	/// Consumes the builder and constructs an Operation<[`WatchEvents`](crate::operation::WatchEvents)>
3395	#[allow(unused_mut)]
3396	#[allow(clippy::let_and_return)]
3397	#[allow(clippy::needless_borrow)]
3398	pub async fn make_operation(
3399		&self,
3400		_config: &crate::config::Config,
3401	) -> std::result::Result<
3402		aws_smithy_http::operation::Operation<crate::operation::WatchEvents, ()>,
3403		aws_smithy_http::operation::BuildError,
3404	> {
3405		let mut request = {
3406			fn uri_base(
3407				_input: &crate::input::WatchEventsInput,
3408				output: &mut String,
3409			) -> Result<(), aws_smithy_http::operation::BuildError> {
3410				write!(output, "/events/live").expect("formatting should succeed");
3411				Ok(())
3412			}
3413			fn uri_query(
3414				_input: &crate::input::WatchEventsInput,
3415				mut output: &mut String,
3416			) -> Result<(), aws_smithy_http::operation::BuildError> {
3417				let mut query = aws_smithy_http::query::Writer::new(&mut output);
3418				if let Some(inner_29) = &_input.watch_index {
3419					query.push_kv(
3420						"watch_index",
3421						&aws_smithy_http::query::fmt_string(&inner_29),
3422					);
3423				}
3424				Ok(())
3425			}
3426			#[allow(clippy::unnecessary_wraps)]
3427			fn update_http_builder(
3428				input: &crate::input::WatchEventsInput,
3429				_config: &crate::config::Config,
3430				builder: http::request::Builder,
3431			) -> std::result::Result<http::request::Builder, aws_smithy_http::operation::BuildError>
3432			{
3433				let mut _uri = String::new();
3434				_uri = format!("{}{}", _config.uri.clone(), _uri);
3435				uri_base(input, &mut _uri)?;
3436				uri_query(input, &mut _uri)?;
3437				Ok(builder.method("GET").uri(_uri))
3438			}
3439			let mut builder = update_http_builder(&self, _config, http::request::Builder::new())?;
3440			let mut builder = if let Some(auth) = &_config.auth {
3441				builder.header(http::header::AUTHORIZATION, auth.clone())
3442			} else {
3443				builder
3444			};
3445			builder
3446		};
3447		let mut properties = aws_smithy_http::property_bag::SharedPropertyBag::new();
3448		#[allow(clippy::useless_conversion)]
3449		let body = aws_smithy_http::body::SdkBody::from("");
3450		let request = request.body(body).expect("should be valid request");
3451		let mut request = aws_smithy_http::operation::Request::from_parts(request, properties);
3452		request
3453			.properties_mut()
3454			.insert(aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
3455		let op = aws_smithy_http::operation::Operation::new(
3456			request,
3457			crate::operation::WatchEvents::new(),
3458		)
3459		.with_metadata(aws_smithy_http::operation::Metadata::new(
3460			"WatchEvents",
3461			"IdentityService",
3462		));
3463		Ok(op)
3464	}
3465	/// Creates a new builder-style object to manufacture [`WatchEventsInput`](crate::input::WatchEventsInput)
3466	pub fn builder() -> crate::input::watch_events_input::Builder {
3467		crate::input::watch_events_input::Builder::default()
3468	}
3469}
3470
3471#[allow(missing_docs)] // documentation missing in model
3472#[non_exhaustive]
3473#[derive(std::clone::Clone, std::cmp::PartialEq)]
3474pub struct ListActivitiesInput {
3475	/// A query parameter denoting the requests watch index.
3476	pub watch_index: std::option::Option<std::string::String>,
3477}
3478impl ListActivitiesInput {
3479	/// A query parameter denoting the requests watch index.
3480	pub fn watch_index(&self) -> std::option::Option<&str> {
3481		self.watch_index.as_deref()
3482	}
3483}
3484impl std::fmt::Debug for ListActivitiesInput {
3485	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3486		let mut formatter = f.debug_struct("ListActivitiesInput");
3487		formatter.field("watch_index", &self.watch_index);
3488		formatter.finish()
3489	}
3490}
3491
3492#[allow(missing_docs)] // documentation missing in model
3493#[non_exhaustive]
3494#[derive(std::clone::Clone, std::cmp::PartialEq)]
3495pub struct CancelGameLinkInput {
3496	/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
3497	pub identity_link_token: std::option::Option<std::string::String>,
3498}
3499impl CancelGameLinkInput {
3500	/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
3501	pub fn identity_link_token(&self) -> std::option::Option<&str> {
3502		self.identity_link_token.as_deref()
3503	}
3504}
3505impl std::fmt::Debug for CancelGameLinkInput {
3506	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3507		let mut formatter = f.debug_struct("CancelGameLinkInput");
3508		formatter.field("identity_link_token", &"*** Sensitive Data Redacted ***");
3509		formatter.finish()
3510	}
3511}
3512
3513#[allow(missing_docs)] // documentation missing in model
3514#[non_exhaustive]
3515#[derive(std::clone::Clone, std::cmp::PartialEq)]
3516pub struct CompleteGameLinkInput {
3517	/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
3518	pub identity_link_token: std::option::Option<std::string::String>,
3519}
3520impl CompleteGameLinkInput {
3521	/// A JSON Web Token. Slightly modified to include a description prefix and use Protobufs of JSON.
3522	pub fn identity_link_token(&self) -> std::option::Option<&str> {
3523		self.identity_link_token.as_deref()
3524	}
3525}
3526impl std::fmt::Debug for CompleteGameLinkInput {
3527	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3528		let mut formatter = f.debug_struct("CompleteGameLinkInput");
3529		formatter.field("identity_link_token", &"*** Sensitive Data Redacted ***");
3530		formatter.finish()
3531	}
3532}
3533
3534#[allow(missing_docs)] // documentation missing in model
3535#[non_exhaustive]
3536#[derive(std::clone::Clone, std::cmp::PartialEq)]
3537pub struct GetGameLinkInput {
3538	/// `identity_link_token` returned by `PrepareGameLink`.
3539	pub identity_link_token: std::option::Option<std::string::String>,
3540	/// A query parameter denoting the requests watch index.
3541	pub watch_index: std::option::Option<std::string::String>,
3542}
3543impl GetGameLinkInput {
3544	/// `identity_link_token` returned by `PrepareGameLink`.
3545	pub fn identity_link_token(&self) -> std::option::Option<&str> {
3546		self.identity_link_token.as_deref()
3547	}
3548	/// A query parameter denoting the requests watch index.
3549	pub fn watch_index(&self) -> std::option::Option<&str> {
3550		self.watch_index.as_deref()
3551	}
3552}
3553impl std::fmt::Debug for GetGameLinkInput {
3554	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3555		let mut formatter = f.debug_struct("GetGameLinkInput");
3556		formatter.field("identity_link_token", &"*** Sensitive Data Redacted ***");
3557		formatter.field("watch_index", &self.watch_index);
3558		formatter.finish()
3559	}
3560}
3561
3562#[allow(missing_docs)] // documentation missing in model
3563#[non_exhaustive]
3564#[derive(std::clone::Clone, std::cmp::PartialEq)]
3565pub struct PrepareGameLinkInput {}
3566impl std::fmt::Debug for PrepareGameLinkInput {
3567	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3568		let mut formatter = f.debug_struct("PrepareGameLinkInput");
3569		formatter.finish()
3570	}
3571}
3572
3573#[allow(missing_docs)] // documentation missing in model
3574#[non_exhaustive]
3575#[derive(std::clone::Clone, std::cmp::PartialEq)]
3576pub struct WatchEventsInput {
3577	/// A query parameter denoting the requests watch index.
3578	pub watch_index: std::option::Option<std::string::String>,
3579}
3580impl WatchEventsInput {
3581	/// A query parameter denoting the requests watch index.
3582	pub fn watch_index(&self) -> std::option::Option<&str> {
3583		self.watch_index.as_deref()
3584	}
3585}
3586impl std::fmt::Debug for WatchEventsInput {
3587	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3588		let mut formatter = f.debug_struct("WatchEventsInput");
3589		formatter.field("watch_index", &self.watch_index);
3590		formatter.finish()
3591	}
3592}
3593
3594#[allow(missing_docs)] // documentation missing in model
3595#[non_exhaustive]
3596#[derive(std::clone::Clone, std::cmp::PartialEq)]
3597pub struct ListMutualFriendsInput {
3598	/// A universally unique identifier.
3599	pub identity_id: std::option::Option<std::string::String>,
3600	#[allow(missing_docs)] // documentation missing in model
3601	pub anchor: std::option::Option<std::string::String>,
3602	/// Unsigned 32 bit integer.
3603	pub limit: std::option::Option<i32>,
3604}
3605impl ListMutualFriendsInput {
3606	/// A universally unique identifier.
3607	pub fn identity_id(&self) -> std::option::Option<&str> {
3608		self.identity_id.as_deref()
3609	}
3610	#[allow(missing_docs)] // documentation missing in model
3611	pub fn anchor(&self) -> std::option::Option<&str> {
3612		self.anchor.as_deref()
3613	}
3614	/// Unsigned 32 bit integer.
3615	pub fn limit(&self) -> std::option::Option<i32> {
3616		self.limit
3617	}
3618}
3619impl std::fmt::Debug for ListMutualFriendsInput {
3620	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3621		let mut formatter = f.debug_struct("ListMutualFriendsInput");
3622		formatter.field("identity_id", &self.identity_id);
3623		formatter.field("anchor", &self.anchor);
3624		formatter.field("limit", &self.limit);
3625		formatter.finish()
3626	}
3627}
3628
3629#[allow(missing_docs)] // documentation missing in model
3630#[non_exhaustive]
3631#[derive(std::clone::Clone, std::cmp::PartialEq)]
3632pub struct GetIdentitySummariesInput {
3633	/// A list of identity IDs.
3634	pub identity_ids: std::option::Option<std::vec::Vec<std::string::String>>,
3635}
3636impl GetIdentitySummariesInput {
3637	/// A list of identity IDs.
3638	pub fn identity_ids(&self) -> std::option::Option<&[std::string::String]> {
3639		self.identity_ids.as_deref()
3640	}
3641}
3642impl std::fmt::Debug for GetIdentitySummariesInput {
3643	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3644		let mut formatter = f.debug_struct("GetIdentitySummariesInput");
3645		formatter.field("identity_ids", &self.identity_ids);
3646		formatter.finish()
3647	}
3648}
3649
3650#[allow(missing_docs)] // documentation missing in model
3651#[non_exhaustive]
3652#[derive(std::clone::Clone, std::cmp::PartialEq)]
3653pub struct GetIdentityHandlesInput {
3654	/// A list of identity IDs.
3655	pub identity_ids: std::option::Option<std::vec::Vec<std::string::String>>,
3656}
3657impl GetIdentityHandlesInput {
3658	/// A list of identity IDs.
3659	pub fn identity_ids(&self) -> std::option::Option<&[std::string::String]> {
3660		self.identity_ids.as_deref()
3661	}
3662}
3663impl std::fmt::Debug for GetIdentityHandlesInput {
3664	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3665		let mut formatter = f.debug_struct("GetIdentityHandlesInput");
3666		formatter.field("identity_ids", &self.identity_ids);
3667		formatter.finish()
3668	}
3669}
3670
3671#[allow(missing_docs)] // documentation missing in model
3672#[non_exhaustive]
3673#[derive(std::clone::Clone, std::cmp::PartialEq)]
3674pub struct ReportIdentityInput {
3675	/// A universally unique identifier.
3676	pub identity_id: std::option::Option<std::string::String>,
3677	#[allow(missing_docs)] // documentation missing in model
3678	pub reason: std::option::Option<std::string::String>,
3679}
3680impl ReportIdentityInput {
3681	/// A universally unique identifier.
3682	pub fn identity_id(&self) -> std::option::Option<&str> {
3683		self.identity_id.as_deref()
3684	}
3685	#[allow(missing_docs)] // documentation missing in model
3686	pub fn reason(&self) -> std::option::Option<&str> {
3687		self.reason.as_deref()
3688	}
3689}
3690impl std::fmt::Debug for ReportIdentityInput {
3691	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3692		let mut formatter = f.debug_struct("ReportIdentityInput");
3693		formatter.field("identity_id", &self.identity_id);
3694		formatter.field("reason", &self.reason);
3695		formatter.finish()
3696	}
3697}
3698
3699#[allow(missing_docs)] // documentation missing in model
3700#[non_exhaustive]
3701#[derive(std::clone::Clone, std::cmp::PartialEq)]
3702pub struct ListFriendsInput {
3703	#[allow(missing_docs)] // documentation missing in model
3704	pub anchor: std::option::Option<std::string::String>,
3705	/// Unsigned 32 bit integer.
3706	pub limit: std::option::Option<i32>,
3707}
3708impl ListFriendsInput {
3709	#[allow(missing_docs)] // documentation missing in model
3710	pub fn anchor(&self) -> std::option::Option<&str> {
3711		self.anchor.as_deref()
3712	}
3713	/// Unsigned 32 bit integer.
3714	pub fn limit(&self) -> std::option::Option<i32> {
3715		self.limit
3716	}
3717}
3718impl std::fmt::Debug for ListFriendsInput {
3719	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3720		let mut formatter = f.debug_struct("ListFriendsInput");
3721		formatter.field("anchor", &self.anchor);
3722		formatter.field("limit", &self.limit);
3723		formatter.finish()
3724	}
3725}
3726
3727#[allow(missing_docs)] // documentation missing in model
3728#[non_exhaustive]
3729#[derive(std::clone::Clone, std::cmp::PartialEq)]
3730pub struct ListFollowingInput {
3731	/// A universally unique identifier.
3732	pub identity_id: std::option::Option<std::string::String>,
3733	#[allow(missing_docs)] // documentation missing in model
3734	pub anchor: std::option::Option<std::string::String>,
3735	/// Unsigned 32 bit integer.
3736	pub limit: std::option::Option<i32>,
3737}
3738impl ListFollowingInput {
3739	/// A universally unique identifier.
3740	pub fn identity_id(&self) -> std::option::Option<&str> {
3741		self.identity_id.as_deref()
3742	}
3743	#[allow(missing_docs)] // documentation missing in model
3744	pub fn anchor(&self) -> std::option::Option<&str> {
3745		self.anchor.as_deref()
3746	}
3747	/// Unsigned 32 bit integer.
3748	pub fn limit(&self) -> std::option::Option<i32> {
3749		self.limit
3750	}
3751}
3752impl std::fmt::Debug for ListFollowingInput {
3753	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3754		let mut formatter = f.debug_struct("ListFollowingInput");
3755		formatter.field("identity_id", &self.identity_id);
3756		formatter.field("anchor", &self.anchor);
3757		formatter.field("limit", &self.limit);
3758		formatter.finish()
3759	}
3760}
3761
3762#[allow(missing_docs)] // documentation missing in model
3763#[non_exhaustive]
3764#[derive(std::clone::Clone, std::cmp::PartialEq)]
3765pub struct ListFollowersInput {
3766	/// A universally unique identifier.
3767	pub identity_id: std::option::Option<std::string::String>,
3768	#[allow(missing_docs)] // documentation missing in model
3769	pub anchor: std::option::Option<std::string::String>,
3770	/// Unsigned 32 bit integer.
3771	pub limit: std::option::Option<i32>,
3772}
3773impl ListFollowersInput {
3774	/// A universally unique identifier.
3775	pub fn identity_id(&self) -> std::option::Option<&str> {
3776		self.identity_id.as_deref()
3777	}
3778	#[allow(missing_docs)] // documentation missing in model
3779	pub fn anchor(&self) -> std::option::Option<&str> {
3780		self.anchor.as_deref()
3781	}
3782	/// Unsigned 32 bit integer.
3783	pub fn limit(&self) -> std::option::Option<i32> {
3784		self.limit
3785	}
3786}
3787impl std::fmt::Debug for ListFollowersInput {
3788	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3789		let mut formatter = f.debug_struct("ListFollowersInput");
3790		formatter.field("identity_id", &self.identity_id);
3791		formatter.field("anchor", &self.anchor);
3792		formatter.field("limit", &self.limit);
3793		formatter.finish()
3794	}
3795}
3796
3797#[allow(missing_docs)] // documentation missing in model
3798#[non_exhaustive]
3799#[derive(std::clone::Clone, std::cmp::PartialEq)]
3800pub struct SignupForBetaInput {
3801	#[allow(missing_docs)] // documentation missing in model
3802	pub name: std::option::Option<std::string::String>,
3803	#[allow(missing_docs)] // documentation missing in model
3804	pub company_name: std::option::Option<std::string::String>,
3805	#[allow(missing_docs)] // documentation missing in model
3806	pub company_size: std::option::Option<std::string::String>,
3807	#[allow(missing_docs)] // documentation missing in model
3808	pub preferred_tools: std::option::Option<std::string::String>,
3809	#[allow(missing_docs)] // documentation missing in model
3810	pub goals: std::option::Option<std::string::String>,
3811}
3812impl SignupForBetaInput {
3813	#[allow(missing_docs)] // documentation missing in model
3814	pub fn name(&self) -> std::option::Option<&str> {
3815		self.name.as_deref()
3816	}
3817	#[allow(missing_docs)] // documentation missing in model
3818	pub fn company_name(&self) -> std::option::Option<&str> {
3819		self.company_name.as_deref()
3820	}
3821	#[allow(missing_docs)] // documentation missing in model
3822	pub fn company_size(&self) -> std::option::Option<&str> {
3823		self.company_size.as_deref()
3824	}
3825	#[allow(missing_docs)] // documentation missing in model
3826	pub fn preferred_tools(&self) -> std::option::Option<&str> {
3827		self.preferred_tools.as_deref()
3828	}
3829	#[allow(missing_docs)] // documentation missing in model
3830	pub fn goals(&self) -> std::option::Option<&str> {
3831		self.goals.as_deref()
3832	}
3833}
3834impl std::fmt::Debug for SignupForBetaInput {
3835	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3836		let mut formatter = f.debug_struct("SignupForBetaInput");
3837		formatter.field("name", &self.name);
3838		formatter.field("company_name", &self.company_name);
3839		formatter.field("company_size", &self.company_size);
3840		formatter.field("preferred_tools", &self.preferred_tools);
3841		formatter.field("goals", &self.goals);
3842		formatter.finish()
3843	}
3844}
3845
3846#[allow(missing_docs)] // documentation missing in model
3847#[non_exhaustive]
3848#[derive(std::clone::Clone, std::cmp::PartialEq)]
3849pub struct CompleteIdentityAvatarUploadInput {
3850	/// A universally unique identifier.
3851	pub upload_id: std::option::Option<std::string::String>,
3852}
3853impl CompleteIdentityAvatarUploadInput {
3854	/// A universally unique identifier.
3855	pub fn upload_id(&self) -> std::option::Option<&str> {
3856		self.upload_id.as_deref()
3857	}
3858}
3859impl std::fmt::Debug for CompleteIdentityAvatarUploadInput {
3860	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3861		let mut formatter = f.debug_struct("CompleteIdentityAvatarUploadInput");
3862		formatter.field("upload_id", &self.upload_id);
3863		formatter.finish()
3864	}
3865}
3866
3867#[allow(missing_docs)] // documentation missing in model
3868#[non_exhaustive]
3869#[derive(std::clone::Clone, std::cmp::PartialEq)]
3870pub struct PrepareIdentityAvatarUploadInput {
3871	/// The path/filename of the identity avatar.
3872	pub path: std::option::Option<std::string::String>,
3873	/// The MIME type of the identity avatar.
3874	pub mime: std::option::Option<std::string::String>,
3875	/// Unsigned 64 bit integer.
3876	pub content_length: std::option::Option<i64>,
3877}
3878impl PrepareIdentityAvatarUploadInput {
3879	/// The path/filename of the identity avatar.
3880	pub fn path(&self) -> std::option::Option<&str> {
3881		self.path.as_deref()
3882	}
3883	/// The MIME type of the identity avatar.
3884	pub fn mime(&self) -> std::option::Option<&str> {
3885		self.mime.as_deref()
3886	}
3887	/// Unsigned 64 bit integer.
3888	pub fn content_length(&self) -> std::option::Option<i64> {
3889		self.content_length
3890	}
3891}
3892impl std::fmt::Debug for PrepareIdentityAvatarUploadInput {
3893	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3894		let mut formatter = f.debug_struct("PrepareIdentityAvatarUploadInput");
3895		formatter.field("path", &self.path);
3896		formatter.field("mime", &self.mime);
3897		formatter.field("content_length", &self.content_length);
3898		formatter.finish()
3899	}
3900}
3901
3902#[allow(missing_docs)] // documentation missing in model
3903#[non_exhaustive]
3904#[derive(std::clone::Clone, std::cmp::PartialEq)]
3905pub struct UnfollowIdentityInput {
3906	/// A universally unique identifier.
3907	pub identity_id: std::option::Option<std::string::String>,
3908}
3909impl UnfollowIdentityInput {
3910	/// A universally unique identifier.
3911	pub fn identity_id(&self) -> std::option::Option<&str> {
3912		self.identity_id.as_deref()
3913	}
3914}
3915impl std::fmt::Debug for UnfollowIdentityInput {
3916	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3917		let mut formatter = f.debug_struct("UnfollowIdentityInput");
3918		formatter.field("identity_id", &self.identity_id);
3919		formatter.finish()
3920	}
3921}
3922
3923#[allow(missing_docs)] // documentation missing in model
3924#[non_exhaustive]
3925#[derive(std::clone::Clone, std::cmp::PartialEq)]
3926pub struct FollowIdentityInput {
3927	/// A universally unique identifier.
3928	pub identity_id: std::option::Option<std::string::String>,
3929}
3930impl FollowIdentityInput {
3931	/// A universally unique identifier.
3932	pub fn identity_id(&self) -> std::option::Option<&str> {
3933		self.identity_id.as_deref()
3934	}
3935}
3936impl std::fmt::Debug for FollowIdentityInput {
3937	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3938		let mut formatter = f.debug_struct("FollowIdentityInput");
3939		formatter.field("identity_id", &self.identity_id);
3940		formatter.finish()
3941	}
3942}
3943
3944#[allow(missing_docs)] // documentation missing in model
3945#[non_exhaustive]
3946#[derive(std::clone::Clone, std::cmp::PartialEq)]
3947pub struct UpdateIdentityStatusInput {
3948	/// The current status of an identity. This helps players understand if another player is currently playing or has their game in the background.
3949	pub status: std::option::Option<crate::model::IdentityStatus>,
3950}
3951impl UpdateIdentityStatusInput {
3952	/// The current status of an identity. This helps players understand if another player is currently playing or has their game in the background.
3953	pub fn status(&self) -> std::option::Option<&crate::model::IdentityStatus> {
3954		self.status.as_ref()
3955	}
3956}
3957impl std::fmt::Debug for UpdateIdentityStatusInput {
3958	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3959		let mut formatter = f.debug_struct("UpdateIdentityStatusInput");
3960		formatter.field("status", &self.status);
3961		formatter.finish()
3962	}
3963}
3964
3965#[allow(missing_docs)] // documentation missing in model
3966#[non_exhaustive]
3967#[derive(std::clone::Clone, std::cmp::PartialEq)]
3968pub struct RemoveIdentityGameActivityInput {}
3969impl std::fmt::Debug for RemoveIdentityGameActivityInput {
3970	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3971		let mut formatter = f.debug_struct("RemoveIdentityGameActivityInput");
3972		formatter.finish()
3973	}
3974}
3975
3976#[allow(missing_docs)] // documentation missing in model
3977#[non_exhaustive]
3978#[derive(std::clone::Clone, std::cmp::PartialEq)]
3979pub struct SetIdentityGameActivityInput {
3980	/// Information about the identity's current game. This is information that all other identities can see about what the current identity is doing.
3981	pub game_activity: std::option::Option<crate::model::UpdateIdentityGameActivity>,
3982}
3983impl SetIdentityGameActivityInput {
3984	/// Information about the identity's current game. This is information that all other identities can see about what the current identity is doing.
3985	pub fn game_activity(&self) -> std::option::Option<&crate::model::UpdateIdentityGameActivity> {
3986		self.game_activity.as_ref()
3987	}
3988}
3989impl std::fmt::Debug for SetIdentityGameActivityInput {
3990	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3991		let mut formatter = f.debug_struct("SetIdentityGameActivityInput");
3992		formatter.field("game_activity", &self.game_activity);
3993		formatter.finish()
3994	}
3995}
3996
3997#[allow(missing_docs)] // documentation missing in model
3998#[non_exhaustive]
3999#[derive(std::clone::Clone, std::cmp::PartialEq)]
4000pub struct SearchIdentitiesInput {
4001	/// The query to match identity display names and account numbers against.
4002	pub query: std::option::Option<std::string::String>,
4003	/// How many identities to offset the search by.
4004	pub anchor: std::option::Option<std::string::String>,
4005	/// Amount of identities to return.
4006	pub limit: std::option::Option<i32>,
4007}
4008impl SearchIdentitiesInput {
4009	/// The query to match identity display names and account numbers against.
4010	pub fn query(&self) -> std::option::Option<&str> {
4011		self.query.as_deref()
4012	}
4013	/// How many identities to offset the search by.
4014	pub fn anchor(&self) -> std::option::Option<&str> {
4015		self.anchor.as_deref()
4016	}
4017	/// Amount of identities to return.
4018	pub fn limit(&self) -> std::option::Option<i32> {
4019		self.limit
4020	}
4021}
4022impl std::fmt::Debug for SearchIdentitiesInput {
4023	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4024		let mut formatter = f.debug_struct("SearchIdentitiesInput");
4025		formatter.field("query", &self.query);
4026		formatter.field("anchor", &self.anchor);
4027		formatter.field("limit", &self.limit);
4028		formatter.finish()
4029	}
4030}
4031
4032#[allow(missing_docs)] // documentation missing in model
4033#[non_exhaustive]
4034#[derive(std::clone::Clone, std::cmp::PartialEq)]
4035pub struct ValidateIdentityProfileInput {
4036	/// Represent a resource's readable display name.
4037	pub display_name: std::option::Option<std::string::String>,
4038	/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
4039	pub account_number: std::option::Option<i32>,
4040	/// Detailed information about a profile.
4041	pub bio: std::option::Option<std::string::String>,
4042}
4043impl ValidateIdentityProfileInput {
4044	/// Represent a resource's readable display name.
4045	pub fn display_name(&self) -> std::option::Option<&str> {
4046		self.display_name.as_deref()
4047	}
4048	/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
4049	pub fn account_number(&self) -> std::option::Option<i32> {
4050		self.account_number
4051	}
4052	/// Detailed information about a profile.
4053	pub fn bio(&self) -> std::option::Option<&str> {
4054		self.bio.as_deref()
4055	}
4056}
4057impl std::fmt::Debug for ValidateIdentityProfileInput {
4058	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4059		let mut formatter = f.debug_struct("ValidateIdentityProfileInput");
4060		formatter.field("display_name", &self.display_name);
4061		formatter.field("account_number", &self.account_number);
4062		formatter.field("bio", &self.bio);
4063		formatter.finish()
4064	}
4065}
4066
4067#[allow(missing_docs)] // documentation missing in model
4068#[non_exhaustive]
4069#[derive(std::clone::Clone, std::cmp::PartialEq)]
4070pub struct UpdateIdentityProfileInput {
4071	/// Represent a resource's readable display name.
4072	pub display_name: std::option::Option<std::string::String>,
4073	/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
4074	pub account_number: std::option::Option<i32>,
4075	/// Detailed information about a profile.
4076	pub bio: std::option::Option<std::string::String>,
4077}
4078impl UpdateIdentityProfileInput {
4079	/// Represent a resource's readable display name.
4080	pub fn display_name(&self) -> std::option::Option<&str> {
4081		self.display_name.as_deref()
4082	}
4083	/// Identity profile account number (#1234). These are assigned in addition to an identity's display name in order to allow multiple identities to have the same display name while still providing a unique handle. These are unique to each display name; you can have multiple accounts with different display names and the same account number.
4084	pub fn account_number(&self) -> std::option::Option<i32> {
4085		self.account_number
4086	}
4087	/// Detailed information about a profile.
4088	pub fn bio(&self) -> std::option::Option<&str> {
4089		self.bio.as_deref()
4090	}
4091}
4092impl std::fmt::Debug for UpdateIdentityProfileInput {
4093	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4094		let mut formatter = f.debug_struct("UpdateIdentityProfileInput");
4095		formatter.field("display_name", &self.display_name);
4096		formatter.field("account_number", &self.account_number);
4097		formatter.field("bio", &self.bio);
4098		formatter.finish()
4099	}
4100}
4101
4102#[allow(missing_docs)] // documentation missing in model
4103#[non_exhaustive]
4104#[derive(std::clone::Clone, std::cmp::PartialEq)]
4105pub struct GetIdentitySelfProfileInput {
4106	/// A query parameter denoting the requests watch index.
4107	pub watch_index: std::option::Option<std::string::String>,
4108}
4109impl GetIdentitySelfProfileInput {
4110	/// A query parameter denoting the requests watch index.
4111	pub fn watch_index(&self) -> std::option::Option<&str> {
4112		self.watch_index.as_deref()
4113	}
4114}
4115impl std::fmt::Debug for GetIdentitySelfProfileInput {
4116	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4117		let mut formatter = f.debug_struct("GetIdentitySelfProfileInput");
4118		formatter.field("watch_index", &self.watch_index);
4119		formatter.finish()
4120	}
4121}
4122
4123#[allow(missing_docs)] // documentation missing in model
4124#[non_exhaustive]
4125#[derive(std::clone::Clone, std::cmp::PartialEq)]
4126pub struct GetIdentityProfileInput {
4127	/// A universally unique identifier.
4128	pub identity_id: std::option::Option<std::string::String>,
4129	/// A query parameter denoting the requests watch index.
4130	pub watch_index: std::option::Option<std::string::String>,
4131}
4132impl GetIdentityProfileInput {
4133	/// A universally unique identifier.
4134	pub fn identity_id(&self) -> std::option::Option<&str> {
4135		self.identity_id.as_deref()
4136	}
4137	/// A query parameter denoting the requests watch index.
4138	pub fn watch_index(&self) -> std::option::Option<&str> {
4139		self.watch_index.as_deref()
4140	}
4141}
4142impl std::fmt::Debug for GetIdentityProfileInput {
4143	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4144		let mut formatter = f.debug_struct("GetIdentityProfileInput");
4145		formatter.field("identity_id", &self.identity_id);
4146		formatter.field("watch_index", &self.watch_index);
4147		formatter.finish()
4148	}
4149}
4150
4151#[allow(missing_docs)] // documentation missing in model
4152#[non_exhaustive]
4153#[derive(std::clone::Clone, std::cmp::PartialEq)]
4154pub struct SetupIdentityInput {
4155	/// Token returned from previous call to `rivet.api.identity#SetupIdentity`. If this token is invalid, a new identity will be returned.
4156	pub existing_identity_token: std::option::Option<std::string::String>,
4157}
4158impl SetupIdentityInput {
4159	/// Token returned from previous call to `rivet.api.identity#SetupIdentity`. If this token is invalid, a new identity will be returned.
4160	pub fn existing_identity_token(&self) -> std::option::Option<&str> {
4161		self.existing_identity_token.as_deref()
4162	}
4163}
4164impl std::fmt::Debug for SetupIdentityInput {
4165	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4166		let mut formatter = f.debug_struct("SetupIdentityInput");
4167		formatter.field(
4168			"existing_identity_token",
4169			&"*** Sensitive Data Redacted ***",
4170		);
4171		formatter.finish()
4172	}
4173}
rivet_identity/input.rs

rivet_identity/
input.rs
