base64

https://docs.rs/base64/latest/base64/
Admin
A Rust library for correct, fast, and configurable base64 encoding and decoding with support for...
Tokens:36,367
Snippets:579
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Initialize and Customize GeneralPurposeConfig

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/struct.GeneralPurposeConfig.html?search=

Example of creating a new configuration and modifying the padding setting.

```rust
let config = GeneralPurposeConfig::new()
    .with_encode_padding(false);
    // further customize using `.with_*` methods as needed
```

--------------------------------

### Decoding base64 with DecoderReader

Source: https://docs.rs/base64/latest/base64/read/struct.DecoderReader.html?search=

Example showing how to wrap a reader with DecoderReader to decode base64 data.

```rust
use std::io::Read;
use std::io::Cursor;
use base64::engine::general_purpose;

// use a cursor as the simplest possible `Read` -- in real code this is probably a file, etc.
let mut wrapped_reader = Cursor::new(b"YXNkZg==");
let mut decoder = base64::read::DecoderReader::new(
    &mut wrapped_reader,
    &general_purpose::STANDARD);

// handle errors as you normally would
let mut result = Vec::new();
decoder.read_to_end(&mut result).unwrap();

assert_eq!(b"asdf", &result[..]);
```

--------------------------------

### Custom Alphabet Usage

Source: https://docs.rs/base64/latest/base64/alphabet/struct.Alphabet.html?search=u32+-%3E+bool

Examples of creating and using custom alphabets in different contexts.

```rust
let custom = base64::alphabet::Alphabet::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").unwrap();

let engine = base64::engine::GeneralPurpose::new(
    &custom,
    base64::engine::general_purpose::PAD);
```

```rust
use base64::alphabet::Alphabet;

static CUSTOM: Alphabet = {
    // Result::unwrap() isn't const yet, but panic!() is OK
    match Alphabet::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/") {
        Ok(x) => x,
        Err(_) => panic!("creation of alphabet failed"),
    }
};
```

```rust
use base64::alphabet::Alphabet;
use std::sync::LazyLock;

static CUSTOM: LazyLock<Alphabet> = LazyLock::new(||
    Alphabet::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").unwrap()
);
```

--------------------------------

### Using EncoderWriter

Source: https://docs.rs/base64/latest/base64/write/struct.EncoderWriter.html

Example of using EncoderWriter to encode data into a buffer.

```rust
use std::io::Write;
use base64::engine::general_purpose;

// use a vec as the simplest possible `Write` -- in real code this is probably a file, etc.
let mut enc = base64::write::EncoderWriter::new(Vec::new(), &general_purpose::STANDARD);

// handle errors as you normally would
enc.write_all(b"asdf").unwrap();

// could leave this out to be called by Drop, if you don't care
// about handling errors or getting the delegate writer back
let delegate = enc.finish().unwrap();

// base64 was written to the writer
assert_eq!(b"YXNkZg==", &delegate[..]);
```

--------------------------------

### Example Usage of decoded_len_estimate

Source: https://docs.rs/base64/latest/base64/fn.decoded_len_estimate.html?search=std%3A%3Avec

Demonstrates how the function rounds up to the next group of 3 decoded bytes based on the input length.

```rust
use base64::decoded_len_estimate;

assert_eq!(3, decoded_len_estimate(1));
assert_eq!(3, decoded_len_estimate(2));
assert_eq!(3, decoded_len_estimate(3));
assert_eq!(3, decoded_len_estimate(4));
// start of the next quad of encoded symbols
assert_eq!(6, decoded_len_estimate(5));
```

--------------------------------

### base64::prelude Engine Presets

Source: https://docs.rs/base64/latest/base64/prelude/index.html?search=std%3A%3Avec

The prelude module exposes several preconfigured engines for base64 operations. These include BASE64_STANDARD, BASE64_STANDARD_NO_PAD, BASE64_URL_SAFE, and BASE64_URL_SAFE_NO_PAD.

```APIDOC
## base64::prelude Engine Presets

### Description
The prelude module provides re-exported engine constants for common base64 encoding and decoding tasks. These engines are configured to enforce no trailing bits during decoding.

### Available Constants
- **BASE64_STANDARD**: Standard base64 encoding/decoding engine.
- **BASE64_STANDARD_NO_PAD**: Standard base64 engine without padding.
- **BASE64_URL_SAFE**: URL-safe base64 encoding/decoding engine.
- **BASE64_URL_SAFE_NO_PAD**: URL-safe base64 engine without padding.

### Usage Example
```rust
use base64::prelude::{Engine as _, BASE64_STANDARD_NO_PAD};

assert_eq!("c29tZSBieXRlcw", &BASE64_STANDARD_NO_PAD.encode(b"some bytes"));
```
```

--------------------------------

### GeneralPurposeConfig::new

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/struct.GeneralPurposeConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new configuration instance with default settings: padding enabled, trailing bits disallowed, and canonical padding required.

```APIDOC
## pub const fn new() -> Self

### Description
Creates a new config with `padding` = `true`, `decode_allow_trailing_bits` = `false`, and `decode_padding_mode = DecodePaddingMode::RequireCanonicalPadding`.
```

--------------------------------

### GeneralPurposeConfig Methods

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/struct.GeneralPurposeConfig.html?search=std%3A%3Avec

Methods for creating and configuring a GeneralPurposeConfig instance.

```APIDOC
## GeneralPurposeConfig::new()

### Description
Creates a new configuration with default settings: padding enabled, trailing bits disallowed, and canonical padding required.

## GeneralPurposeConfig::with_encode_padding(padding: bool)

### Description
Returns a new config with the padding setting updated. If true, encoding appends '=' characters to ensure output length is a multiple of 4.

## GeneralPurposeConfig::with_decode_allow_trailing_bits(allow: bool)

### Description
Returns a new config with the decode_allow_trailing_bits setting updated. If true, invalid trailing bits are ignored during decoding.

## GeneralPurposeConfig::with_decode_padding_mode(mode: DecodePaddingMode)

### Description
Returns a new config with the decode_padding_mode setting updated. Controls how the decoder validates padding (e.g., RequireCanonicalPadding, Indifferent, or RequireNoPadding).
```

--------------------------------

### Create new Base64Display instance

Source: https://docs.rs/base64/latest/base64/display/struct.Base64Display.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructor for creating a new Base64Display instance with a provided engine.

```rust
pub fn new(bytes: &'a [u8], engine: &'e E) -> Base64Display<'a, 'e, E>
```

--------------------------------

### Avx2 Constructors

Source: https://docs.rs/base64/latest/base64/engine/simd/struct.Avx2.html?search=u32+-%3E+bool

Methods to initialize an Avx2 engine instance for base64 operations.

```APIDOC
## pub fn standard(config: GeneralPurposeConfig) -> Option<Self>

### Description
Creates an Avx2 engine for the STANDARD alphabet if the CPU supports AVX2. Returns None if AVX2 is not detected.

## pub fn url_safe(config: GeneralPurposeConfig) -> Option<Self>

### Description
Creates an Avx2 engine for the URL_SAFE alphabet if the CPU supports AVX2. Returns None if AVX2 is not detected.

## pub const unsafe fn standard_unchecked(config: GeneralPurposeConfig) -> Self

### Description
Creates an Avx2 engine for the STANDARD alphabet without runtime AVX2 support checks. 

### Safety
The caller must ensure the CPU supports AVX2; usage on unsupported hardware results in undefined behavior.

## pub const unsafe fn url_safe_unchecked(config: GeneralPurposeConfig) -> Self

### Description
Creates an Avx2 engine for the URL_SAFE alphabet without runtime AVX2 support checks.

### Safety
The caller must ensure the CPU supports AVX2; usage on unsupported hardware results in undefined behavior.
```

--------------------------------

### Base64Display::new

Source: https://docs.rs/base64/latest/base64/display/index.html?search=

Creates a new Base64Display wrapper to format bytes as base64 using a specified engine.

```APIDOC
## Base64Display::new

### Description
Creates a new wrapper that implements `Display` for base64 encoding of byte slices without heap allocation.

### Signature
`pub fn new(bytes: &'a [u8], engine: &'a E) -> Base64Display<'a, E>`

### Parameters
- **bytes** (&[u8]) - The byte slice to encode.
- **engine** (&E) - The base64 engine to use for encoding (e.g., `base64::engine::general_purpose::STANDARD`).

### Example
```rust
use base64::{display::Base64Display, engine::general_purpose::STANDARD};

let data = vec![0x0, 0x1, 0x2, 0x3];
let wrapper = Base64Display::new(&data, &STANDARD);

assert_eq!("base64: AAECAw==", format!("base64: {}", wrapper));
```
```

--------------------------------

### Create and use a custom Alphabet

Source: https://docs.rs/base64/latest/base64/alphabet/struct.Alphabet.html

Demonstrates initializing a custom Alphabet and using it to construct a GeneralPurpose engine.

```rust
let custom = base64::alphabet::Alphabet::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/").unwrap();

let engine = base64::engine::GeneralPurpose::new(
    &custom,
    base64::engine::general_purpose::PAD);
```

--------------------------------

### Base64Display::new

Source: https://docs.rs/base64/latest/base64/display/struct.Base64Display.html

Creates a new Base64Display instance to wrap bytes for base64 formatting.

```APIDOC
## pub fn new(bytes: &'a [u8], engine: &'e E) -> Base64Display<'a, 'e, E>

### Description
Creates a new `Base64Display` instance with the provided byte slice and base64 engine. This allows for base64 encoding during formatting operations without requiring heap allocation.

### Parameters
- **bytes** (&[u8]) - The byte slice to be encoded.
- **engine** (&E) - The base64 engine to use for encoding.
```

--------------------------------

### GeneralPurpose::new

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/struct.GeneralPurpose.html?search=std%3A%3Avec

Creates a new GeneralPurpose engine instance using the specified alphabet and configuration.

```APIDOC
## pub const fn new(alphabet: &Alphabet, config: GeneralPurposeConfig) -> Self

### Description
Creates a new GeneralPurpose engine instance. It is recommended to cache this instance if it will be used repeatedly.

### Parameters
- **alphabet** (&Alphabet) - The alphabet to use for encoding/decoding.
- **config** (GeneralPurposeConfig) - The configuration settings for the engine.
```

--------------------------------

### GeneralPurposeConfig Methods

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/struct.GeneralPurposeConfig.html?search=

Methods available for configuring base64 encoding and decoding behavior.

```APIDOC
## pub const fn new() -> Self

### Description
Creates a new configuration with default settings: padding enabled, trailing bits disallowed, and canonical padding required.

## pub const fn with_encode_padding(self, padding: bool) -> Self

### Description
Updates the padding setting. If true, encoding appends '=' characters to ensure output length is a multiple of 4.

## pub const fn with_decode_allow_trailing_bits(self, allow: bool) -> Self

### Description
Configures whether to ignore invalid trailing bits in the last base64 character. If false, invalid bits result in a DecodeError.

## pub const fn with_decode_padding_mode(self, mode: DecodePaddingMode) -> Self

### Description
Sets the validation mode for padding during decoding. Options include RequireCanonicalPadding, Indifferent, or RequireNoPadding.
```

--------------------------------

### Simd::standard

Source: https://docs.rs/base64/latest/base64/engine/simd/struct.Simd.html

Creates a new Simd engine configured for the STANDARD base64 alphabet.

```APIDOC
## Simd::standard

### Description
Creates a `Simd` engine for the STANDARD alphabet, detecting the instruction set once at runtime.

### Signature
`pub fn standard(config: GeneralPurposeConfig) -> Self`
```

--------------------------------

### fn config(&self) -> &Self::Config

Source: https://docs.rs/base64/latest/base64/engine/trait.Engine.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the configuration object associated with the current engine instance.

```APIDOC
## fn config(&self) -> &Self::Config

### Description
Returns the configuration type used by this engine.

### Returns
- **&Self::Config** - A reference to the engine's configuration.
```

--------------------------------

### Encode bytes using BASE64_STANDARD_NO_PAD

Source: https://docs.rs/base64/latest/base64/prelude/index.html?search=

Demonstrates encoding a byte slice using the preconfigured BASE64_STANDARD_NO_PAD engine.

```rust
use base64::prelude::{Engine as _, BASE64_STANDARD_NO_PAD};

assert_eq!("c29tZSBieXRlcw", &BASE64_STANDARD_NO_PAD.encode(b"some bytes"));
```

--------------------------------

### Custom Engine Configuration

Source: https://docs.rs/base64/latest/base64/index.html?search=

Creates a custom engine by defining a unique alphabet and specific GeneralPurposeConfig settings.

```rust
use base64::{engine, alphabet, Engine as _};

// bizarro-world base64: +/ as the first symbols instead of the last
let alphabet =
    alphabet::Alphabet::new("+/ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")
    .unwrap();

// a very weird config that encodes with padding but requires no padding when decoding...?
let crazy_config = engine::GeneralPurposeConfig::new()
    .with_decode_allow_trailing_bits(true)
    .with_encode_padding(true)
    .with_decode_padding_mode(engine::DecodePaddingMode::RequireNone);

let crazy_engine = engine::GeneralPurpose::new(&alphabet, crazy_config);

let encoded = crazy_engine.encode(b"abc 123");
```

--------------------------------

### Avx2::standard

Source: https://docs.rs/base64/latest/base64/engine/simd/struct.Avx2.html

Creates an Avx2 engine for the STANDARD alphabet if the CPU supports AVX2.

```APIDOC
## pub fn standard(config: GeneralPurposeConfig) -> Option<Self>

### Description
Creates an Avx2 engine for the STANDARD alphabet if the running CPU supports AVX2, otherwise returns None. This method requires the 'std' feature for runtime detection.

### Parameters
- **config** (GeneralPurposeConfig) - Required - The configuration for the base64 engine.
```

--------------------------------

### Alphabet::new

Source: https://docs.rs/base64/latest/base64/alphabet/struct.Alphabet.html

Creates a new Alphabet instance from a 64-character string, using '=' as the default padding symbol.

```APIDOC
## Alphabet::new(alphabet: &str) -> Result<Self, ParseAlphabetError>

### Description
Creates an `Alphabet` from a string of 64 unique printable ASCII bytes with '=' as the padding symbol. The padding symbol '=' is not allowed in the alphabet string.

### Parameters
- **alphabet** (&str) - Required - A string containing 64 unique printable ASCII characters.
```

--------------------------------

### Standard Padding Behavior

Source: https://docs.rs/base64/latest/base64/index.html?search=

Demonstrates how canonical base64 encoding adds padding characters to ensure output length is a multiple of 4.

```rust
use base64::{engine::general_purpose::STANDARD, Engine as _};

assert_eq!(STANDARD.encode(b""),    "");
assert_eq!(STANDARD.encode(b"f"),   "Zg==");
assert_eq!(STANDARD.encode(b"fo"),  "Zm8=");
assert_eq!(STANDARD.encode(b"foo"), "Zm9v");
```

--------------------------------

### Alphabet Methods

Source: https://docs.rs/base64/latest/base64/alphabet/struct.Alphabet.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods to retrieve information from an existing Alphabet instance.

```APIDOC
## Alphabet Methods

### as_str(&self) -> &str
Returns a `&str` containing the symbols in the `Alphabet` (excluding padding).

### symbols(&self) -> [Symbol; 64]
Returns the 64 symbols of the alphabet (excluding padding).

### padding(&self) -> Symbol
Returns the symbol used for padding.
```

--------------------------------

### Format bytes as base64 using Base64Display

Source: https://docs.rs/base64/latest/base64/display/index.html

Use Base64Display to encode bytes into a format string. This approach avoids heap allocation during the formatting process.

```rust
use base64::{display::Base64Display, engine::general_purpose::STANDARD};

let data = vec![0x0, 0x1, 0x2, 0x3];
let wrapper = Base64Display::new(&data, &STANDARD);

assert_eq!("base64: AAECAw==", format!("base64: {}", wrapper));
```

--------------------------------

### Avx2::url_safe

Source: https://docs.rs/base64/latest/base64/engine/simd/struct.Avx2.html

Creates an Avx2 engine for the URL_SAFE alphabet if the CPU supports AVX2.

```APIDOC
## pub fn url_safe(config: GeneralPurposeConfig) -> Option<Self>

### Description
Creates an Avx2 engine for the URL_SAFE alphabet if the running CPU supports AVX2, otherwise returns None. This method requires the 'std' feature for runtime detection.

### Parameters
- **config** (GeneralPurposeConfig) - Required - The configuration for the base64 engine.
```

--------------------------------

### Append base64 to an existing String

Source: https://docs.rs/base64/latest/base64/write/struct.EncoderStringWriter.html

Demonstrates using from_consumer to append base64-encoded data to an existing String buffer.

```rust
use std::io::Write;
use base64::engine::general_purpose;

let mut buf = String::from("base64: ");

let mut enc = base64::write::EncoderStringWriter::from_consumer(
    &mut buf,
    &general_purpose::STANDARD);

enc.write_all(b"asdf").unwrap();

// release the &mut reference on buf
let _ = enc.into_inner();

assert_eq!("base64: YXNkZg==", &buf);
```

--------------------------------

### Avx2 Engine Constructors

Source: https://docs.rs/base64/latest/base64/engine/simd/struct.Avx2.html?search=

Methods to instantiate an Avx2 engine for different alphabets, including checked and unchecked variants.

```rust
pub fn standard(config: GeneralPurposeConfig) -> Option<Self>
```

```rust
pub fn url_safe(config: GeneralPurposeConfig) -> Option<Self>
```

```rust
pub const unsafe fn standard_unchecked(config: GeneralPurposeConfig) -> Self
```

```rust
pub const unsafe fn url_safe_unchecked(config: GeneralPurposeConfig) -> Self
```

--------------------------------

### Define a static Alphabet

Source: https://docs.rs/base64/latest/base64/alphabet/struct.Alphabet.html

Shows how to define a static Alphabet using a const block with a panic for error handling.

```rust
use base64::alphabet::Alphabet;

static CUSTOM: Alphabet = {
    // Result::unwrap() isn't const yet, but panic!() is OK
    match Alphabet::new("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/") {
        Ok(x) => x,
        Err(_) => panic!("creation of alphabet failed"),
    }
};
```

--------------------------------

### Alphabet Accessor Methods

Source: https://docs.rs/base64/latest/base64/alphabet/struct.Alphabet.html

Methods to retrieve information about an existing Alphabet instance.

```APIDOC
## Alphabet Accessors

### as_str()
Returns a `&str` containing the symbols in the `Alphabet` (excluding padding).

### symbols()
Returns an array of 64 `Symbol` values representing the alphabet (excluding padding).

### padding()
Returns the `Symbol` used for padding in this alphabet.
```

--------------------------------

### Simd::url_safe

Source: https://docs.rs/base64/latest/base64/engine/simd/struct.Simd.html

Creates a new Simd engine configured for the URL_SAFE base64 alphabet.

```APIDOC
## Simd::url_safe

### Description
Creates a `Simd` engine for the URL_SAFE alphabet, detecting the instruction set once at runtime.

### Signature
`pub fn url_safe(config: GeneralPurposeConfig) -> Self`
```

--------------------------------

### Buffer base64 into a new String

Source: https://docs.rs/base64/latest/base64/write/struct.EncoderStringWriter.html

Demonstrates creating a new EncoderStringWriter to encode data into a fresh String instance.

```rust
use std::io::Write;
use base64::engine::general_purpose;

let mut enc = base64::write::EncoderStringWriter::new(&general_purpose::STANDARD);

enc.write_all(b"asdf").unwrap();

// get the resulting String
let b64_string = enc.into_inner();

assert_eq!("YXNkZg==", &b64_string);
```

--------------------------------

### Encode and Decode with Standard Alphabet

Source: https://docs.rs/base64/latest/base64/index.html?search=

Uses the pre-configured STANDARD engine from the prelude for common RFC 4648 base64 operations.

```rust
use base64::prelude::*;

assert_eq!(BASE64_STANDARD.decode(b"+uwgVQA=")?, b"\xFA\xEC\x20\x55\0");
assert_eq!(BASE64_STANDARD.encode(b"\xFF\xEC\x20\x55\0"), "/+wgVQA=");
```

--------------------------------

### encode<T: AsRef<[u8]>>(&self, input: T) -> String

Source: https://docs.rs/base64/latest/base64/engine/trait.Engine.html

Encodes arbitrary octets as base64 using the provided engine and returns a new String.

```APIDOC
## fn encode<T: AsRef<[u8]>>(&self, input: T) -> String

### Description
Encodes arbitrary octets as base64 using the provided `Engine`. Returns a `String` containing the encoded data.
```

--------------------------------

### fn consume(&mut self, buf: &str)

Source: https://docs.rs/base64/latest/base64/write/trait.StrConsumer.html?search=

Consumes the base64 encoded data provided in the buffer.

```APIDOC
## fn consume(&mut self, buf: &str)

### Description
Consumes the base64 encoded data in `buf`.

### Parameters
- **buf** (&str) - The string slice containing base64 encoded data to be consumed.
```

--------------------------------

### Base64Display

Source: https://docs.rs/base64/latest/base64/display/index.html

A convenience wrapper for base64’ing bytes into a format string without heap allocation.

```APIDOC
## Struct: Base64Display

### Description
A convenience wrapper for base64’ing bytes into a format string without heap allocation. It implements the `Display` trait, enabling base64 output anywhere a `Display` implementation is used.

### Usage Example
```rust
use base64::{display::Base64Display, engine::general_purpose::STANDARD};

let data = vec![0x0, 0x1, 0x2, 0x3];
let wrapper = Base64Display::new(&data, &STANDARD);

assert_eq!("base64: AAECAw==", format!("base64: {}", wrapper));
```
```

--------------------------------

### Encode data to String

Source: https://docs.rs/base64/latest/base64/engine/trait.Engine.html

Demonstrates encoding byte slices into a new String using standard and custom engines.

```rust
use base64::{Engine as _, engine::{self, general_purpose}, alphabet};

let b64 = general_purpose::STANDARD.encode(b"hello world~");
println!("{}", b64);

const CUSTOM_ENGINE: engine::GeneralPurpose =
    engine::GeneralPurpose::new(&alphabet::URL_SAFE, general_purpose::NO_PAD);

let b64_url = CUSTOM_ENGINE.encode(b"hello internet~");
```

--------------------------------

### Implement Display trait with Base64Display

Source: https://docs.rs/base64/latest/base64/index.html?search=

Wraps bytes in Base64Display to enable formatting as base64 strings.

```rust
use base64::{display::Base64Display, engine::general_purpose::STANDARD};

let value = Base64Display::new(b"\0\x01\x02\x03", &STANDARD);
assert_eq!("base64: AAECAw==", format!("base64: {}", value));
```

--------------------------------

### Symbol::new

Source: https://docs.rs/base64/latest/base64/alphabet/struct.Symbol.html

Creates a new Symbol instance if the provided byte is a valid printable ASCII character.

```APIDOC
### pub const fn new(symbol: u8) -> Option<Self>

Creates a new `Symbol` from a `u8` byte. Returns `Some(Symbol)` if the byte is a valid printable ASCII symbol, otherwise returns `None`.
```

--------------------------------

### Avx2::url_safe_unchecked

Source: https://docs.rs/base64/latest/base64/engine/simd/struct.Avx2.html

Creates an Avx2 engine for the URL_SAFE alphabet without runtime CPU checks.

```APIDOC
## pub const unsafe fn url_safe_unchecked(config: GeneralPurposeConfig) -> Self

### Description
Creates an Avx2 engine for the URL_SAFE alphabet without checking for AVX2 support.

### Safety
The CPU that will run encode/decode must support AVX2. Using the engine on a CPU without AVX2 is undefined behavior.

### Parameters
- **config** (GeneralPurposeConfig) - Required - The configuration for the base64 engine.
```

--------------------------------

### GeneralPurpose::encode

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/struct.GeneralPurpose.html?search=std%3A%3Avec

Encodes arbitrary octets as base64 and returns a new String.

```APIDOC
## fn encode<T: AsRef<[u8]>>(&self, input: T) -> String

### Description
Encodes the provided input bytes into a base64-encoded String.

### Parameters
- **input** (T: AsRef<[u8]>) - The input data to encode.

### Returns
- **String** - The base64-encoded representation of the input.
```

--------------------------------

### Avx2::standard_unchecked

Source: https://docs.rs/base64/latest/base64/engine/simd/struct.Avx2.html

Creates an Avx2 engine for the STANDARD alphabet without runtime CPU checks.

```APIDOC
## pub const unsafe fn standard_unchecked(config: GeneralPurposeConfig) -> Self

### Description
Creates an Avx2 engine for the STANDARD alphabet without checking for AVX2 support. 

### Safety
The CPU that will run encode/decode must support AVX2. Using the engine on a CPU without AVX2 is undefined behavior.

### Parameters
- **config** (GeneralPurposeConfig) - Required - The configuration for the base64 engine.
```

--------------------------------

### GeneralPurposeConfig::with_encode_padding

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/struct.GeneralPurposeConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Updates the padding setting for the configuration.

```APIDOC
## pub const fn with_encode_padding(self, padding: bool) -> Self

### Description
Creates a new config based on `self` with an updated `padding` setting. If `padding` is `true`, encoding will append `=` padding characters to ensure output length is a multiple of 4.
```

--------------------------------

### GeneralPurposeConfig Definition

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/struct.GeneralPurposeConfig.html?search=

The internal structure definition for GeneralPurposeConfig.

```rust
pub struct GeneralPurposeConfig { /* private fields */ }
```

--------------------------------

### Avx2 Engine Methods

Source: https://docs.rs/base64/latest/base64/engine/simd/struct.Avx2.html

Methods available for the Avx2 engine to perform base64 encoding and decoding operations.

```APIDOC
## fn encode<T: AsRef<[u8]>>(&self, input: T) -> String

### Description
Encodes arbitrary octets as base64 using the Avx2 engine and returns the result as a new String.

## fn encode_string<T: AsRef<[u8]>>(&self, input: T, output_buf: &mut String)

### Description
Encodes arbitrary octets as base64 into a supplied String buffer.

## fn encode_slice<T: AsRef<[u8]>>(&self, input: T, output_buf: &mut [u8]) -> Result<usize, EncodeSliceError>

### Description
Encodes arbitrary octets as base64 into a provided mutable slice. Returns the number of bytes written or an error.

## fn decode<T: AsRef<[u8]>>(&self, input: T) -> Result<Vec<u8>, DecodeError>

### Description
Decodes base64 input into a new Vec<u8>.

## fn decode_vec<T: AsRef<[u8]>>(&self, input: T, buffer: &mut Vec<u8>) -> Result<(), DecodeError>

### Description
Decodes base64 input into the supplied mutable Vec buffer.

## fn decode_slice<T: AsRef<[u8]>>(&self, input: T, output: &mut [u8]) -> Result<usize, DecodeSliceError>

### Description
Decodes base64 input into the provided mutable output slice. Returns the number of bytes written or an error.

## fn decode_slice_unchecked<T: AsRef<[u8]>>(&self, input: T, output: &mut [u8]) -> Result<usize, DecodeError>

### Description
Decodes base64 input into the provided output slice without performing full validation.
```

--------------------------------

### EncoderWriter::new

Source: https://docs.rs/base64/latest/base64/write/struct.EncoderWriter.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new EncoderWriter that encodes data using the provided engine before writing to the wrapped writer.

```APIDOC
## EncoderWriter::new

### Description
Creates a new instance of EncoderWriter that wraps a writer and uses a specific base64 engine.

### Signature
`pub fn new(writer: W, engine: &'e E) -> EncoderWriter<'e, E, W>`

### Parameters
- **writer** (W) - The underlying writer to delegate to.
- **engine** (&'e E) - The base64 engine to use for encoding.
```

--------------------------------

### GeneralPurposeConfig::with_decode_allow_trailing_bits

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/struct.GeneralPurposeConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Updates the configuration to allow or disallow trailing bits during decoding.

```APIDOC
## pub const fn with_decode_allow_trailing_bits(self, allow: bool) -> Self

### Description
Creates a new config based on `self` with an updated `decode_allow_trailing_bits` setting. If `true`, invalid trailing bits are ignored; otherwise, `DecodeError::InvalidLastSymbol` is emitted.
```

--------------------------------

### pub fn encode_engine_string<E: Engine, T: AsRef<[u8]>>(input: T, output_buf: &mut String, engine: &E)

Source: https://docs.rs/base64/latest/base64/fn.encode_engine_string.html?search=std%3A%3Avec

Encodes arbitrary octets as base64 into a supplied String. This function is deprecated; users should use Engine::encode_string instead.

```APIDOC
## Function: encode_engine_string

### Description
Encodes arbitrary octets as base64 into a supplied `String`. This function is deprecated since 0.21.0; use `Engine::encode_string` instead.

### Signature
`pub fn encode_engine_string<E: Engine, T: AsRef<[u8]>>(input: T, output_buf: &mut String, engine: &E)`

### Parameters
- **input** (T: AsRef<[u8]>) - The input data to encode.
- **output_buf** (&mut String) - The buffer to store the encoded base64 string.
- **engine** (&E) - The engine implementation to use for encoding.
```

--------------------------------

### pub fn encode_engine_string<E: Engine, T: AsRef<[u8]>>(input: T, output_buf: &mut String, engine: &E)

Source: https://docs.rs/base64/latest/base64/fn.encode_engine_string.html

Encodes arbitrary octets as base64 into a supplied String. This function is deprecated; users should use Engine::encode_string instead.

```APIDOC
## encode_engine_string

### Description
Encodes arbitrary octets as base64 into a supplied `String` using the provided `Engine`.

### Signature
`pub fn encode_engine_string<E: Engine, T: AsRef<[u8]>>(input: T, output_buf: &mut String, engine: &E)`

### Parameters
- **input** (T: AsRef<[u8]>) - The input data to encode.
- **output_buf** (&mut String) - The buffer to store the encoded base64 string.
- **engine** (&E) - The engine implementation to use for encoding.

### Deprecation Notice
Deprecated since 0.21.0: Use `Engine::encode_string` instead.
```

--------------------------------

### EncoderWriter::finish

Source: https://docs.rs/base64/latest/base64/write/struct.EncoderWriter.html?search=

Encodes all remaining buffered data and writes it to the delegate, including padding.

```APIDOC
## pub fn finish(&mut self) -> Result<W>

### Description
Encode all remaining buffered data and write it, including any trailing incomplete input triples and associated padding. Once this succeeds, no further writes or calls to this method are allowed.

### Returns
- **Result<W>** - The writer that this was constructed around upon success.
```

--------------------------------

### encode_string<T: AsRef<[u8]>>(&self, input: T, output_buf: &mut String)

Source: https://docs.rs/base64/latest/base64/engine/trait.Engine.html

Encodes arbitrary octets as base64 into a supplied String buffer.

```APIDOC
## fn encode_string<T: AsRef<[u8]>>(&self, input: T, output_buf: &mut String)

### Description
Encodes arbitrary octets as base64 into a supplied `String`. This method writes into the provided `String`, which may trigger an allocation if the internal buffer is insufficient.
```

--------------------------------

### EncoderStringWriter::new

Source: https://docs.rs/base64/latest/base64/write/struct.EncoderStringWriter.html?search=std%3A%3Avec

Creates a new EncoderStringWriter that encodes data into a new String.

```APIDOC
## pub fn new(engine: &'e E) -> Self

### Description
Creates a new EncoderStringWriter that will encode into a new String with the provided engine configuration.

### Parameters
- **engine** (&'e E) - Required - The base64 engine to use for encoding.
```

--------------------------------

### EncoderWriter::finish

Source: https://docs.rs/base64/latest/base64/write/struct.EncoderWriter.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Encodes remaining buffered data, writes it to the delegate, and returns the inner writer.

```APIDOC
## pub fn finish(&mut self) -> Result<W>

### Description
Encode all remaining buffered data and write it, including any trailing incomplete input triples and associated padding. Once this succeeds, no further writes or calls to this method are allowed.
```

--------------------------------

### Decode base64 using the STANDARD engine

Source: https://docs.rs/base64/latest/base64/fn.decode.html

This function is deprecated; use Engine::decode instead.

```rust
pub fn decode<T: AsRef<[u8]>>(input: T) -> Result<Vec<u8>, DecodeError>
```

--------------------------------

### EncoderWriter::new

Source: https://docs.rs/base64/latest/base64/write/struct.EncoderWriter.html?search=

Creates a new encoder that will write base64 encoded data to the provided delegate writer.

```APIDOC
## pub fn new(delegate: W, engine: &'e E) -> EncoderWriter<'e, E, W>

### Description
Create a new encoder that will write to the provided delegate writer.

### Parameters
- **delegate** (W) - The underlying writer to receive encoded data.
- **engine** (&'e E) - The base64 engine to use for encoding.
```

--------------------------------

### fn encode

Source: https://docs.rs/base64/latest/base64/fn.encode.html?search=std%3A%3Avec

Encodes arbitrary octets as base64 using the STANDARD engine.

```APIDOC
## Function: encode

### Description
Encodes arbitrary octets as base64 using the `STANDARD` engine. This function is deprecated since 0.21.0; users are encouraged to use `Engine::encode` instead.

### Signature
`pub fn encode<T: AsRef<[u8]>>(input: T) -> String`

### Parameters
- **input** (T: AsRef<[u8]>) - The input data to be encoded as base64.

### Returns
- **String** - The base64-encoded representation of the input.
```

--------------------------------

### Format Base64Display

Source: https://docs.rs/base64/latest/base64/display/struct.Base64Display.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implementation of the Display trait to format the value using a formatter.

```rust
fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>
```

--------------------------------

### Alphabet::new_with_padding

Source: https://docs.rs/base64/latest/base64/alphabet/struct.Alphabet.html

Creates a new Alphabet instance with a custom padding symbol.

```APIDOC
## Alphabet::new_with_padding(alphabet: &str, padding: Symbol) -> Result<Self, ParseAlphabetError>

### Description
Creates an `Alphabet` from a string of 64 unique printable ASCII bytes, with a custom padding symbol. The padding symbol must not appear in the provided alphabet string.

### Parameters
- **alphabet** (&str) - Required - A string containing 64 unique printable ASCII characters.
- **padding** (Symbol) - Required - The custom symbol to be used for padding.
```

--------------------------------

### PAD constant definition

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/constant.PAD.html

The definition of the PAD constant within the general_purpose engine configuration.

```rust
pub const PAD: GeneralPurposeConfig;
```

--------------------------------

### STANDARD_NO_PAD Constant Definition

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/constant.STANDARD_NO_PAD.html

The constant definition for the STANDARD_NO_PAD engine configuration.

```rust
pub const STANDARD_NO_PAD: GeneralPurpose;
```

--------------------------------

### pub fn encode<T: AsRef<[u8]>>(input: T) -> String

Source: https://docs.rs/base64/latest/base64/fn.encode.html

Encodes arbitrary octets as base64 using the STANDARD engine. This function is deprecated since 0.21.0; users should prefer Engine::encode.

```APIDOC
## Function: encode

### Description
Encodes arbitrary octets as base64 using the `STANDARD` engine. This function is deprecated since 0.21.0.

### Signature
`pub fn encode<T: AsRef<[u8]>>(input: T) -> String`

### Parameters
- **input** (T: AsRef<[u8]>) - Required - The input data to be encoded as base64.

### Returns
- **String** - The base64 encoded representation of the input.
```

--------------------------------

### DecoderReader::new

Source: https://docs.rs/base64/latest/base64/read/struct.DecoderReader.html?search=

Creates a new DecoderReader instance that decodes base64 data from the provided reader using the specified engine.

```APIDOC
## pub fn new(reader: R, engine: &'e E) -> Self

### Description
Creates a new decoder that will read from the provided reader `r` using the provided base64 engine.

### Parameters
- **reader** (R: Read) - The underlying reader to decode from.
- **engine** (&'e E) - The base64 engine to use for decoding.
```

--------------------------------

### DecoderReader::new

Source: https://docs.rs/base64/latest/base64/read/struct.DecoderReader.html?search=u32+-%3E+bool

Creates a new DecoderReader instance that decodes base64 data from the provided reader using the specified engine.

```APIDOC
## pub fn new(reader: R, engine: &'e E) -> Self

### Description
Creates a new decoder that will read from the provided reader `r` using the provided base64 engine.

### Parameters
- **reader** (R) - The underlying reader to decode from.
- **engine** (&'e E) - The base64 engine used for decoding.
```

--------------------------------

### DecoderReader::new

Source: https://docs.rs/base64/latest/base64/read/struct.DecoderReader.html?search=std%3A%3Avec

Creates a new DecoderReader instance that decodes base64 data from the provided reader using the specified engine.

```APIDOC
## pub fn new(reader: R, engine: &'e E) -> Self

### Description
Creates a new decoder that will read from the provided reader `r` using the specified base64 engine.

### Parameters
- **reader** (R) - Required - The underlying reader to decode from.
- **engine** (&'e E) - Required - The base64 engine used for decoding.
```

--------------------------------

### NO_PAD_INDIFFERENT Constant Definition

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/constant.NO_PAD_INDIFFERENT.html

The constant definition for the GeneralPurposeConfig used in base64 operations.

```rust
pub const NO_PAD_INDIFFERENT: GeneralPurposeConfig;
```

--------------------------------

### EncoderStringWriter::new

Source: https://docs.rs/base64/latest/base64/write/struct.EncoderStringWriter.html?search=u32+-%3E+bool

Creates a new EncoderStringWriter that encodes data into a new String using the provided base64 engine.

```APIDOC
## pub fn new(engine: &'e E) -> Self

### Description
Creates a new EncoderStringWriter that will encode into a new String with the provided config.

### Parameters
- **engine** (&'e E) - Required - The base64 engine to use for encoding.
```

--------------------------------

### Accessing the STANDARD constant

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/constant.STANDARD.html

The constant represents a GeneralPurpose engine instance using the standard alphabet and padding configuration.

```rust
pub const STANDARD: GeneralPurpose;
```

--------------------------------

### Engine::encode

Source: https://docs.rs/base64/latest/base64/index.html?search=std%3A%3Avec

Encodes a slice of bytes into a base64 string using the specified engine configuration.

```APIDOC
## Engine::encode

### Description
Encodes input bytes into a base64-encoded string based on the engine's alphabet and padding rules.

### Signature
`fn encode<T: AsRef<[u8]>>(&self, input: T) -> String`

### Example
```rust
use base64::prelude::*;
let encoded = BASE64_STANDARD.encode(b"foo");
assert_eq!(encoded, "Zm9v");
```
```

--------------------------------

### GeneralPurpose Struct Definition

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/struct.GeneralPurpose.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The definition of the GeneralPurpose struct.

```rust
pub struct GeneralPurpose { /* private fields */ }
```

--------------------------------

### URL_SAFE_NO_PAD Constant Definition

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/constant.URL_SAFE_NO_PAD.html

The constant definition for the URL_SAFE_NO_PAD engine.

```rust
pub const URL_SAFE_NO_PAD: GeneralPurpose;
```

--------------------------------

### Avx2 Checked Constructors

Source: https://docs.rs/base64/latest/base64/engine/simd/struct.Avx2.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructors that perform runtime checks for AVX2 support. These require the std feature.

```rust
pub fn standard(config: GeneralPurposeConfig) -> Option<Self>
```

```rust
pub fn url_safe(config: GeneralPurposeConfig) -> Option<Self>
```

--------------------------------

### Padding Rejection

Source: https://docs.rs/base64/latest/base64/index.html?search=

Shows that engines configured without padding will reject inputs containing padding characters.

```rust
assert_eq!(STANDARD_NO_PAD.decode(b"Zm8="), Err(base64::DecodeError::InvalidPadding));
```

--------------------------------

### Stream encode to output

Source: https://docs.rs/base64/latest/base64/index.html?search=

Uses EncoderWriter to encode a byte stream from stdin to stdout.

```rust
use base64::{engine::general_purpose::STANDARD, write::EncoderWriter};

let mut output = io::stdout();
let mut encoder = EncoderWriter::new(&mut output, &STANDARD);
io::copy(&mut io::stdin(), &mut encoder)?;
```

--------------------------------

### decode<T: AsRef<[u8]>>(&self, input: T) -> Result<Vec<u8>, DecodeError>

Source: https://docs.rs/base64/latest/base64/engine/trait.Engine.html

Decodes base64 input into a new Vec<u8>.

```APIDOC
## fn decode<T: AsRef<[u8]>>(&self, input: T) -> Result<Vec<u8>, DecodeError>

### Description
Decodes the provided base64 input into a new `Vec<u8>`.
```

--------------------------------

### GeneralPurposeConfig::with_decode_padding_mode

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/struct.GeneralPurposeConfig.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Updates the padding validation mode for decoding.

```APIDOC
## pub const fn with_decode_padding_mode(self, mode: DecodePaddingMode) -> Self

### Description
Creates a new config based on `self` with an updated `decode_padding_mode` setting. Supported modes include `DecodePaddingMode::Indifferent`, `DecodePaddingMode::RequireCanonicalPadding`, and `DecodePaddingMode::RequireNoPadding`.
```

--------------------------------

### pub fn encode_engine<E: Engine, T: AsRef<[u8]>>(input: T, engine: &E) -> String

Source: https://docs.rs/base64/latest/base64/fn.encode_engine.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Encodes arbitrary octets as base64 using the provided Engine into a new String. Note: This function is deprecated since 0.21.0.

```APIDOC
## Function: encode_engine

### Description
Encodes arbitrary octets as base64 using the provided `Engine` into a new `String`. This function is deprecated since version 0.21.0; users should use `Engine::encode` instead.

### Signature
`pub fn encode_engine<E: Engine, T: AsRef<[u8]>>(input: T, engine: &E) -> String`

### Parameters
- **input** (T: AsRef<[u8]>) - The input data to be encoded.
- **engine** (&E) - The engine implementation to use for encoding.

### Returns
- **String** - The base64 encoded representation of the input.
```

--------------------------------

### Accessing the STANDARD alphabet constant

Source: https://docs.rs/base64/latest/base64/alphabet/constant.STANDARD.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The constant defines the standard base64 alphabet as specified in RFC 4648.

```rust
pub const STANDARD: Alphabet;
```

--------------------------------

### STANDARD_NO_PAD_INDIFFERENT constant definition

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/constant.STANDARD_NO_PAD_INDIFFERENT.html

The constant definition for the GeneralPurpose engine configuration.

```rust
pub const STANDARD_NO_PAD_INDIFFERENT: GeneralPurpose;
```

--------------------------------

### URL_SAFE_PAD_INDIFFERENT Constant Definition

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/constant.URL_SAFE_PAD_INDIFFERENT.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The constant definition for the URL_SAFE_PAD_INDIFFERENT engine.

```rust
pub const URL_SAFE_PAD_INDIFFERENT: GeneralPurpose;
```

--------------------------------

### decode_slice_unchecked<T: AsRef<[u8]>>(&self, input: T, output: &mut [u8]) -> Result<usize, DecodeError>

Source: https://docs.rs/base64/latest/base64/engine/trait.Engine.html

Decodes base64 input into a provided output slice, panicking if the buffer is too small.

```APIDOC
## fn decode_slice_unchecked<T: AsRef<[u8]>>(&self, input: T, output: &mut [u8]) -> Result<usize, DecodeError>

### Description
Decodes the input into the provided output slice. Panics if the provided output buffer is too small for the decoded data.
```

--------------------------------

### Define BIN_HEX constant

Source: https://docs.rs/base64/latest/base64/alphabet/constant.BIN_HEX.html?search=

Represents the alphabet used in BinHex 4.0 files.

```rust
pub const BIN_HEX: Alphabet;
```

--------------------------------

### pub fn encode_engine_string

Source: https://docs.rs/base64/latest/base64/fn.encode_engine_string.html?search=u32+-%3E+bool

Encodes arbitrary octets as base64 into a supplied String. This function is deprecated.

```APIDOC
## Function: encode_engine_string

### Description
Encode arbitrary octets as base64 into a supplied `String`. This function is deprecated since 0.21.0; use `Engine::encode_string` instead.

### Signature
`pub fn encode_engine_string<E: Engine, T: AsRef<[u8]>>(input: T, output_buf: &mut String, engine: &E)`

### Parameters
- **input** (T: AsRef<[u8]>) - The input data to encode.
- **output_buf** (&mut String) - The buffer to store the encoded base64 string.
- **engine** (&E) - The engine implementation to use for encoding.
```

--------------------------------

### Define Base64Display struct

Source: https://docs.rs/base64/latest/base64/display/struct.Base64Display.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The definition of the Base64Display struct with private fields.

```rust
pub struct Base64Display<'a, 'e, E: Engine> { /* private fields */ }
```

--------------------------------

### Stream decode from input

Source: https://docs.rs/base64/latest/base64/index.html?search=

Uses DecoderReader to decode a byte stream from stdin to stdout.

```rust
use base64::{engine::general_purpose::STANDARD, read::DecoderReader};

let mut input = io::stdin();
let mut decoder = DecoderReader::new(&mut input, &STANDARD);
io::copy(&mut decoder, &mut io::stdout())?;
```

--------------------------------

### decode_vec<T: AsRef<[u8]>>(&self, input: T, buffer: &mut Vec<u8>) -> Result<(), DecodeError>

Source: https://docs.rs/base64/latest/base64/engine/trait.Engine.html

Decodes base64 input into a supplied Vec buffer.

```APIDOC
## fn decode_vec<T: AsRef<[u8]>>(&self, input: T, buffer: &mut Vec<u8>) -> Result<(), DecodeError>

### Description
Decodes the `input` into the supplied `buffer`. The `Vec` may allocate if its internal buffer is not large enough.
```

--------------------------------

### Accessing the URL_SAFE constant

Source: https://docs.rs/base64/latest/base64/alphabet/constant.URL_SAFE.html

Displays the definition of the URL_SAFE constant within the base64::alphabet module.

```rust
pub const URL_SAFE: Alphabet;
```

--------------------------------

### pub fn decode<T: AsRef<[u8]>>(input: T) -> Result<Vec<u8>, DecodeError>

Source: https://docs.rs/base64/latest/base64/fn.decode.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Decodes base64 encoded input using the STANDARD engine. Note that this function is deprecated since version 0.21.0 and users are encouraged to use Engine::decode instead.

```APIDOC
## Function: decode

### Description
Decodes base64 encoded data using the `STANDARD` engine. This function is deprecated since version 0.21.0; please use `Engine::decode` instead.

### Signature
`pub fn decode<T: AsRef<[u8]>>(input: T) -> Result<Vec<u8>, DecodeError>`

### Parameters
- **input** (T: AsRef<[u8]>) - Required - The base64 encoded data to decode.

### Returns
- **Result<Vec<u8>, DecodeError>** - Returns a vector of decoded bytes on success, or a `DecodeError` if the input is invalid.
```

--------------------------------

### EncoderWriter::into_inner

Source: https://docs.rs/base64/latest/base64/write/struct.EncoderWriter.html?search=u32+-%3E+bool

Unwraps the EncoderWriter to return the base writer.

```APIDOC
## pub fn into_inner(self) -> W

### Description
Unwraps this EncoderWriter, returning the base writer it writes base64 encoded output to. Note that this does not flush remaining data and may panic if called after a successful finish().

### Returns
- **W** - The underlying writer.
```

--------------------------------

### URL_SAFE_NO_PAD_INDIFFERENT Constant Definition

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/constant.URL_SAFE_NO_PAD_INDIFFERENT.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The definition of the URL_SAFE_NO_PAD_INDIFFERENT constant within the base64 crate.

```rust
pub const URL_SAFE_NO_PAD_INDIFFERENT: GeneralPurpose;
```

--------------------------------

### STANDARD_PAD_INDIFFERENT Constant Definition

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/constant.STANDARD_PAD_INDIFFERENT.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The definition of the STANDARD_PAD_INDIFFERENT constant within the base64 engine.

```rust
pub const STANDARD_PAD_INDIFFERENT: GeneralPurpose;
```

--------------------------------

### base64::write::EncoderWriter

Source: https://docs.rs/base64/latest/base64/write/struct.EncoderWriter.html?search=

A Write implementation that base64 encodes data before delegating to the wrapped writer.

```APIDOC
## Struct: EncoderWriter

### Description
A `Write` implementation that base64 encodes data before delegating to the wrapped writer. It handles padding and finalization of the base64 stream.

### Methods

#### `new(writer: W, engine: &E) -> EncoderWriter<'e, E, W>`
Creates a new `EncoderWriter` that wraps the provided writer and uses the specified base64 engine.

#### `finish() -> Result<W, Error>`
Encodes any remaining input bytes, adds padding if necessary, and returns the underlying writer. This must be called to ensure all data is flushed and to handle potential errors from the underlying writer.

### Panics
Calling `write()` or `finish()` after a successful `finish()` call will result in a panic.
```

--------------------------------

### fn padding(&self) -> Symbol

Source: https://docs.rs/base64/latest/base64/engine/trait.Engine.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the padding symbol used for encoding operations.

```APIDOC
## fn padding(&self) -> Symbol

### Description
Returns the symbol used for encode padding. Typically this is '=', but custom alphabets may define different values.

### Returns
- **Symbol** - The character or symbol used for padding.
```

--------------------------------

### DecoderReader::into_inner

Source: https://docs.rs/base64/latest/base64/read/struct.DecoderReader.html?search=

Unwraps the DecoderReader to return the underlying reader.

```APIDOC
## pub fn into_inner(self) -> R

### Description
Unwraps this `DecoderReader`, returning the base reader which it reads base64 encoded input from. Note that the state of the inner reader is unspecified due to internal buffering.
```

--------------------------------

### Config Trait Definition

Source: https://docs.rs/base64/latest/base64/engine/trait.Config.html

The base trait that all encoding engines must implement to define padding behavior.

```rust
pub trait Config {
    // Required method
    fn encode_padding(&self) -> bool;
}
```

--------------------------------

### Avx2 Struct Definition

Source: https://docs.rs/base64/latest/base64/engine/simd/struct.Avx2.html

The internal structure definition for the Avx2 engine.

```rust
pub struct Avx2 { /* private fields */ }
```

--------------------------------

### Define PAD_INDIFFERENT constant

Source: https://docs.rs/base64/latest/base64/engine/general_purpose/constant.PAD_INDIFFERENT.html?search=std%3A%3Avec

Represents the GeneralPurposeConfig constant used for base64 operations.

```rust
pub const PAD_INDIFFERENT: GeneralPurposeConfig;
```

--------------------------------

### Alphabet Definition

Source: https://docs.rs/base64/latest/base64/alphabet/struct.Alphabet.html?search=

The internal structure definition for the Alphabet type.

```rust
pub struct Alphabet { /* private fields */ }
```
Tokens:
Raw