Struct JsonCodecSettings 

pub struct JsonCodecSettings { /* private fields */ }

Configuration for JSON codec behavior.

Use the builder methods to construct settings:

use aws_smithy_json::codec::JsonCodecSettings;

let settings = JsonCodecSettings::builder()
    .use_json_name(false)
    .build();

As DocumentSettings

JsonCodecSettings implements [DocumentSettings]. The JsonDeserializer attaches Arc<JsonCodecSettings> to every document it produces so the format-aware accessors (DiscriminatedDocument::as_blob, DiscriminatedDocument::as_timestamp) can coerce JSON-encoded blobs (base64 strings) and timestamps (date-time strings or epoch-seconds numbers) back to typed Rust values. The same instance is reused on the serialization side so a document round-trips through JsonDeserializer → JsonSerializer losslessly.

Implementations

impl JsonCodecSettings

pub fn dispatch_null_members(&self) -> bool

Whether null structure members are passed to the consumer instead of skipped. Schema servers use this to clear optional fields while leaving required validation to builders.

pub fn builder() -> JsonCodecSettingsBuilder

Creates a builder for JsonCodecSettings.

pub fn default_timestamp_format(&self) -> TimestampFormat

Default timestamp format when not specified by @timestampFormat trait.

pub fn max_depth(&self) -> u32

Maximum aggregate nesting depth the deserializer will accept before returning an error. Defends against stack overflow on recursive shapes and deeply-nested document payloads.

pub fn strict_timestamp_formats(&self) -> bool

Whether timestamps must use exactly the wire form their format prescribes. See JsonCodecSettingsBuilder::strict_timestamp_formats.

pub fn use_string_for_arbitrary_precision(&self) -> bool

Whether bigInteger and bigDecimal shapes emit as JSON strings (when true) or as raw JSON numbers (when false, the default). The read path is always lenient — read_big_integer and read_big_decimal accept either wire form.

pub fn normalize_arbitrary_precision(&self) -> bool

Whether non-JSON-number arbitrary-precision text is rewritten to the equivalent JSON number (true) or rejected (false, the default). See the field documentation.

pub fn default_namespace(&self) -> Option<&str>

Default Smithy namespace used to resolve relative shape IDs in JSON __type discriminator fields. None if unset.

See the field-level doc comment for Self::default_namespace’s builder method for the resolution behavior.

pub fn to_builder(&self) -> JsonCodecSettingsBuilder

Returns a JsonCodecSettingsBuilder pre-populated with this instance’s current values. Useful for protocol wrappers that need to rebuild a codec with one setting overridden:

use aws_smithy_json::codec::JsonCodecSettings;

let original = JsonCodecSettings::default();
let modified = original.to_builder()
    .default_namespace("com.example")
    .build();

Trait Implementations

impl Clone for JsonCodecSettings

fn clone(&self) -> JsonCodecSettings

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for JsonCodecSettings

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for JsonCodecSettings

fn default() -> Self

Returns the “default value” for a type.

impl DocumentSettings for JsonCodecSettings

fn coerce_string_to_blob(&self, s: &str) -> Result<Vec<u8>, DocumentError>

Decodes a base64 string into a blob.

JSON has no native blob type; the Smithy spec requires blobs to be transmitted as base64-encoded strings on the JSON wire. This method consumes those strings on the deserialization side; the corresponding encode happens in JsonSerializer::write_document.

fn coerce_string_to_timestamp(&self, s: &str) -> Result<DateTime, DocumentError>

Parses a string-formatted timestamp using the codec’s default timestamp format (JsonCodecSettings::default_timestamp_format).

Per the SEP, untyped JSON documents have no schema-level @timestampFormat trait to consult, so the codec’s default format is the only signal. AWS JSON / restJson1 default to epoch-seconds — but a string-typed JSON value cannot be epoch-seconds (which is a number). For this case we attempt date-time parsing as a fallback so common ISO-8601 strings still coerce.

fn coerce_number_to_timestamp( &self, n: &Number, ) -> Result<DateTime, DocumentError>

Coerces a number to a timestamp interpreted as epoch-seconds.

Number-typed JSON values are only valid timestamps when the codec’s default format is epoch-seconds. Per the SEP this is the AWS JSON / restJson1 default. If the codec has been configured with a non-numeric default format (date-time / http-date), this method returns an UnsupportedOperation error — a number value isn’t valid for those formats.

fn protocol_id(&self) -> &str

The Smithy fully-qualified shape ID of the protocol that produced this document, e.g. "aws.protocols#restJson1".