---
editLink: false
lastUpdated: false
outline: [2, 3]
---

<!-- Generated by python/b2c-tooling-sdk/scripts/generate_api_docs.py. Do not edit. -->

# b2c_tooling_sdk.config

Configuration loading utilities.

Mirrors `src/config/index.ts`. The preferred high-level API is
[`resolve_config`](/python/api/config#resolve-config), which returns a rich [`ResolvedConfigImpl`](/python/api/config#resolvedconfigimpl) with
validation predicates and auth-strategy factory methods.

Resolution priority (highest to lowest): explicit overrides, then configuration
sources (dw.json, ~/.mobify, package.json). Later sources only fill in missing
values. Hostname-mismatch protection prevents mixing credentials across
instances.

To go straight from configuration to a usable client, use
[`create_instance_from_config`](/python/api/config#create-instance-from-config) or [`ResolvedConfigImpl.create_b2c_instance`](/python/api/config#resolvedconfigimpl-create-b2c-instance).

Example:

```python
from b2c_tooling_sdk.config import resolve_config
from b2c_tooling_sdk.config.types import NormalizedConfig

config = await resolve_config(
    NormalizedConfig(hostname="example.com", client_id="...")
)
if config.has_oauth_config():
    strategy = config.create_oauth()
```

## Classes

### ConfigCatalogFile {#configcatalogfile}

```python
class ConfigCatalogFile
```

A dw.json file participating in the effective instance catalog.

**Fields**

| Name | Type |
| --- | --- |
| `location` | `str` |
| `scope` | `Literal['global', 'primary']` |
| `selected` | `bool` |

### ConfigLoadResult {#configloadresult}

```python
class ConfigLoadResult
```

Result of loading configuration from a single source.

**Fields**

| Name | Type | Default |
| --- | --- | --- |
| `config` | `NormalizedConfig` |  |
| `scope` | `Literal['global'] \| None` | `None` |
| `instance_catalog` | `list[ConfigCatalogFile] \| None` | `None` |
| `location` | `str \| None` | `None` |

### ConfigResolutionResult {#configresolutionresult}

```python
class ConfigResolutionResult
```

Result of configuration resolution.

**Fields**

| Name | Type |
| --- | --- |
| `config` | `NormalizedConfig` |
| `warnings` | `list[ConfigWarning]` |
| `sources` | `list[ConfigSourceInfo]` |

### ConfigResolver {#configresolver}

```python
class ConfigResolver
```

Resolves configuration from multiple sources with consistent behaviour.

#### resolve <Badge type="info" text="method" /> {#configresolver-resolve}

```python
async def resolve(overrides: NormalizedConfig | None = None, options: ResolveConfigOptions | None = None) -> ConfigResolutionResult
```

Resolve configuration from all sources, applying override precedence.

#### create_auth_credentials <Badge type="info" text="method" /> {#configresolver-create-auth-credentials}

```python
async def create_auth_credentials(overrides: NormalizedConfig | None = None, options: ResolveConfigOptions | None = None) -> AuthCredentials
```

Resolve config and return [`AuthCredentials`](/python/api/auth#authcredentials) for `resolve_auth_strategy`.

#### create_instance <Badge type="info" text="method" /> {#configresolver-create-instance}

```python
async def create_instance(overrides: NormalizedConfig | None = None, options: ResolveConfigOptions | None = None) -> B2CInstance
```

Resolve configuration and create a [`B2CInstance`](/python/api/instance#b2cinstance).

A convenience method combining `resolve` with instance creation. Any
resolution warnings are logged.

**Raises**

- `ValueError` — if no hostname is available in the resolved config.

### ConfigSource {#configsource}

```python
class ConfigSource(Protocol)
```

A configuration source that can contribute config values.

Implement this protocol to create custom configuration sources. The required
surface is `name` and `load`. Sources may optionally implement the
instance-management and credential-storage methods; consumers probe for them
with `getattr` / `hasattr` at runtime.

**Fields**

| Name | Type |
| --- | --- |
| `name` | `str` |

#### load <Badge type="info" text="method" /> {#configsource-load}

```python
def load(options: ResolveConfigOptions) -> MaybePromise[ConfigLoadResult | None]
```

Load configuration from this source (may be sync or async).

### ConfigSourceInfo {#configsourceinfo}

```python
class ConfigSourceInfo
```

Information about a configuration source that participated in resolution.

**Fields**

| Name | Type | Default |
| --- | --- | --- |
| `name` | `str` |  |
| `fields` | `list[str]` |  |
| `scope` | `Literal['global'] \| None` | `None` |
| `location` | `str \| None` | `None` |
| `fields_ignored` | `list[str] \| None` | `None` |
| `instance_catalog` | `list[ConfigCatalogFile] \| None` | `None` |

### ConfigSourceRegistry {#configsourceregistry}

```python
class ConfigSourceRegistry
```

Registry that collects [`ConfigSource`](/python/api/config#configsource) instances for resolution.

**Fields**

| Name | Type | Description |
| --- | --- | --- |
| `size` | `int` | Number of registered sources. |

#### register <Badge type="info" text="method" /> {#configsourceregistry-register}

```python
def register(source: ConfigSource) -> None
```

Register a source (ignored if a source with the same name exists).

#### unregister <Badge type="info" text="method" /> {#configsourceregistry-unregister}

```python
def unregister(name: str) -> bool
```

Remove a source by name; returns True if one was removed.

#### get_sources <Badge type="info" text="method" /> {#configsourceregistry-get-sources}

```python
def get_sources() -> list[ConfigSource]
```

Return a shallow copy of all registered sources.

#### clear <Badge type="info" text="method" /> {#configsourceregistry-clear}

```python
def clear() -> None
```

Remove all registered sources (primarily useful for testing).

#### get_source_names <Badge type="info" text="method" /> {#configsourceregistry-get-source-names}

```python
def get_source_names() -> list[str]
```

Return the names of all registered sources.

### ConfigWarning {#configwarning}

```python
class ConfigWarning
```

A warning generated during configuration resolution.

**Fields**

| Name | Type | Default |
| --- | --- | --- |
| `code` | `ConfigWarningCode` |  |
| `message` | `str` |  |
| `details` | `dict[str, Any] \| None` | `None` |

### CreateB2CInstanceOptions {#createb2cinstanceoptions}

```python
class CreateB2CInstanceOptions
```

Options for constructing a B2C instance from resolved configuration.

**Fields**

| Name | Type | Default |
| --- | --- | --- |
| `redirect_uri` | `str \| None` | `None` |
| `open_browser` | `Callable[[str], Awaitable[None]] \| None` | `None` |
| `oauth_strategy` | `AuthStrategy \| Callable[[], AuthStrategy] \| None` | `None` |

### CreateInstanceOptions {#createinstanceoptions}

```python
class CreateInstanceOptions
```

Options for creating an instance in a dw.json-style source.

Flattens the TypeScript `CreateInstanceOptions & ResolveConfigOptions`
intersection: it carries the instance `name`/`config` plus the subset of
resolution fields a dw.json source needs to locate the target file.

**Fields**

| Name | Type | Default |
| --- | --- | --- |
| `name` | `str` |  |
| `config` | `NormalizedConfig` |  |
| `set_active` | `bool` | `False` |
| `config_path` | `str \| None` | `None` |
| `project_directory` | `str \| None` | `None` |
| `working_directory` | `str \| None` | `None` |
| `default_config_path` | `str \| None` | `None` |

### CreateOAuthOptions {#createoauthoptions}

```python
class CreateOAuthOptions
```

Options for creating an OAuth auth strategy.

**Fields**

| Name | Type | Default |
| --- | --- | --- |
| `allowed_methods` | `list[AuthMethod] \| None` | `None` |
| `scopes` | `list[str] \| None` | `None` |
| `redirect_uri` | `str \| None` | `None` |
| `open_browser` | `Callable[[str], Awaitable[None]] \| None` | `None` |

### DwJsonSource {#dwjsonsource}

```python
class DwJsonSource
```

Configuration source that loads from dw.json files.

#### load <Badge type="info" text="method" /> {#dwjsonsource-load}

```python
async def load(options: ResolveConfigOptions) -> ConfigLoadResult | None
```

Load configuration for the requested (or active/root) instance.

#### list_instances <Badge type="info" text="method" /> {#dwjsonsource-list-instances}

```python
async def list_instances(options: ResolveConfigOptions | None = None) -> list[InstanceInfo]
```

List all instances across the effective dw.json files (deduped by name).

#### create_instance <Badge type="info" text="method" /> {#dwjsonsource-create-instance}

```python
async def create_instance(options: CreateInstanceOptions) -> None
```

Create a new instance in dw.json.

#### remove_instance <Badge type="info" text="method" /> {#dwjsonsource-remove-instance}

```python
async def remove_instance(name: str, options: ResolveConfigOptions | None = None) -> None
```

Remove an instance from the dw.json file that contains it.

#### set_active_instance <Badge type="info" text="method" /> {#dwjsonsource-set-active-instance}

```python
async def set_active_instance(name: str, options: ResolveConfigOptions | None = None) -> None
```

Set an instance active, clearing active flags in the other catalog files.

### EnvSource {#envsource}

```python
class EnvSource
```

Configuration source that reads CLI configuration environment variables.

Priority `-10` (higher than dw.json at `0`), matching CLI behaviour where
env vars override file-based config.

#### load <Badge type="info" text="method" /> {#envsource-load}

```python
def load(options: ResolveConfigOptions) -> ConfigLoadResult | None
```

Load config from environment variables (synchronous).

### InstanceInfo {#instanceinfo}

```python
class InstanceInfo
```

Information about a configured instance.

**Fields**

| Name | Type | Default |
| --- | --- | --- |
| `name` | `str` |  |
| `source` | `str` |  |
| `hostname` | `str \| None` | `None` |
| `active` | `bool \| None` | `None` |
| `location` | `str \| None` | `None` |

### InstanceManager {#instancemanager}

```python
class InstanceManager
```

Aggregates instance-management operations across multiple config sources.

#### list_all_instances <Badge type="info" text="method" /> {#instancemanager-list-all-instances}

```python
async def list_all_instances(options: ResolveConfigOptions | None = None) -> list[InstanceInfo]
```

List instances from every source that implements `list_instances`.

#### get_instance_sources <Badge type="info" text="method" /> {#instancemanager-get-instance-sources}

```python
def get_instance_sources() -> list[ConfigSource]
```

Return sources that can create instances.

#### get_credential_sources <Badge type="info" text="method" /> {#instancemanager-get-credential-sources}

```python
def get_credential_sources(field: str) -> list[ConfigSource]
```

Return sources that can store the given credential field.

#### create_instance <Badge type="info" text="method" /> {#instancemanager-create-instance}

```python
async def create_instance(options: CreateInstanceOptions, target_source: str | None = None) -> None
```

Create an instance in the target source (or the first available one).

#### remove_instance <Badge type="info" text="method" /> {#instancemanager-remove-instance}

```python
async def remove_instance(name: str, options: ResolveConfigOptions | None = None) -> None
```

Remove an instance from whichever source contains it.

#### set_active_instance <Badge type="info" text="method" /> {#instancemanager-set-active-instance}

```python
async def set_active_instance(name: str, options: ResolveConfigOptions | None = None) -> None
```

Set an instance active in whichever source contains it.

#### store_credential <Badge type="info" text="method" /> {#instancemanager-store-credential}

```python
async def store_credential(instance_name: str, field: str, value: str, target_source: str | None = None, options: ResolveConfigOptions | None = None) -> None
```

Store a credential for an instance in the target credential source.

### LibraryEntry {#libraryentry}

```python
class LibraryEntry
```

A configured content library entry.

The simpler `str` form (an ID alone) is equivalent to
`LibraryEntry(id=..., site_library=False)`.

**Fields**

| Name | Type | Default |
| --- | --- | --- |
| `id` | `str` |  |
| `site_library` | `bool` | `False` |

### LoadDwJsonResult {#loaddwjsonresult}

```python
class LoadDwJsonResult
```

The selected dw.json config plus the file path it came from.

**Fields**

| Name | Type |
| --- | --- |
| `config` | `DwJsonConfig` |
| `path` | `str` |

### NormalizedConfig {#normalizedconfig}

```python
class NormalizedConfig
```

Normalized B2C configuration with snake_case fields.

The canonical intermediate format that all configuration sources map to,
regardless of their on-disk format (dw.json kebab/camelCase, env vars, etc.).

**Fields**

| Name | Type | Default |
| --- | --- | --- |
| `hostname` | `str \| None` | `None` |
| `webdav_hostname` | `str \| None` | `None` |
| `code_version` | `str \| None` | `None` |
| `username` | `str \| None` | `None` |
| `password` | `str \| None` | `None` |
| `client_id` | `str \| None` | `None` |
| `client_secret` | `str \| None` | `None` |
| `scopes` | `list[str] \| None` | `None` |
| `auth_methods` | `list[AuthMethod] \| None` | `None` |
| `account_manager_host` | `str \| None` | `None` |
| `jwt_cert_path` | `str \| None` | `None` |
| `jwt_key_path` | `str \| None` | `None` |
| `jwt_passphrase` | `str \| None` | `None` |
| `slas_client_id` | `str \| None` | `None` |
| `slas_client_secret` | `str \| None` | `None` |
| `site_id` | `str \| None` | `None` |
| `short_code` | `str \| None` | `None` |
| `tenant_id` | `str \| None` | `None` |
| `sandbox_api_host` | `str \| None` | `None` |
| `realm` | `str \| None` | `None` |
| `mrt_project` | `str \| None` | `None` |
| `mrt_environment` | `str \| None` | `None` |
| `mrt_api_key` | `str \| None` | `None` |
| `mrt_origin` | `str \| None` | `None` |
| `auto_upload` | `bool \| None` | `None` |
| `cartridges` | `list[str] \| None` | `None` |
| `import_set_exclude` | `list[str] \| None` | `None` |
| `content_library` | `str \| None` | `None` |
| `catalogs` | `list[str] \| None` | `None` |
| `libraries` | `list[str \| LibraryEntry] \| None` | `None` |
| `asset_query` | `list[str] \| None` | `None` |
| `cip_host` | `str \| None` | `None` |
| `docs_categories` | `list[str] \| None` | `None` |
| `instance_name` | `str \| None` | `None` |
| `project_directory` | `str \| None` | `None` |
| `working_directory` | `str \| None` | `None` |
| `certificate` | `str \| None` | `None` |
| `certificate_passphrase` | `str \| None` | `None` |
| `self_signed` | `bool \| None` | `None` |
| `api_backend` | `Literal['ocapi', 'scapi', 'auto'] \| None` | `None` |

### ResolveConfigOptions {#resolveconfigoptions}

```python
class ResolveConfigOptions
```

Options for configuration resolution.

**Fields**

| Name | Type | Default |
| --- | --- | --- |
| `instance` | `str \| None` | `None` |
| `config_path` | `str \| None` | `None` |
| `default_config_path` | `str \| None` | `None` |
| `project_directory` | `str \| None` | `None` |
| `working_directory` | `str \| None` | `None` |
| `hostname_protection` | `bool \| None` | `None` |
| `client_id_protection` | `bool \| None` | `None` |
| `cloud_origin` | `str \| None` | `None` |
| `credentials_file` | `str \| None` | `None` |
| `account_manager_host` | `str \| None` | `None` |
| `sources_before` | `list[ConfigSource] \| None` | `None` |
| `sources_after` | `list[ConfigSource] \| None` | `None` |
| `replace_default_sources` | `bool` | `False` |

### ResolvedConfigImpl {#resolvedconfigimpl}

```python
class ResolvedConfigImpl
```

Resolved configuration with validation and auth-strategy factories.

#### has_b2c_instance_config <Badge type="info" text="method" /> {#resolvedconfigimpl-has-b2c-instance-config}

```python
def has_b2c_instance_config() -> bool
```

Whether a B2C instance can be created (requires a hostname).

#### has_mrt_config <Badge type="info" text="method" /> {#resolvedconfigimpl-has-mrt-config}

```python
def has_mrt_config() -> bool
```

Whether MRT credentials are available (requires an MRT API key).

#### has_oauth_config <Badge type="info" text="method" /> {#resolvedconfigimpl-has-oauth-config}

```python
def has_oauth_config() -> bool
```

Whether OAuth can be used (requires a client id).

#### has_basic_auth_config <Badge type="info" text="method" /> {#resolvedconfigimpl-has-basic-auth-config}

```python
def has_basic_auth_config() -> bool
```

Whether basic auth can be used (requires username and password).

#### create_b2c_instance <Badge type="info" text="method" /> {#resolvedconfigimpl-create-b2c-instance}

```python
def create_b2c_instance(options: CreateB2CInstanceOptions | None = None) -> B2CInstance
```

Create a [`B2CInstance`](/python/api/instance#b2cinstance) from the resolved config.

**Raises**

- `ValueError` — if no hostname is available (see `has_b2c_instance_config`).

#### create_basic_auth <Badge type="info" text="method" /> {#resolvedconfigimpl-create-basic-auth}

```python
def create_basic_auth() -> AuthStrategy
```

Create a [`BasicAuthStrategy`](/python/api/auth#basicauthstrategy) from the resolved credentials.

#### create_oauth <Badge type="info" text="method" /> {#resolvedconfigimpl-create-oauth}

```python
def create_oauth(options: CreateOAuthOptions | None = None) -> AuthStrategy
```

Create an OAuth strategy, merging any additional scopes over config scopes.

#### create_mrt_auth <Badge type="info" text="method" /> {#resolvedconfigimpl-create-mrt-auth}

```python
def create_mrt_auth() -> AuthStrategy
```

Create an [`ApiKeyStrategy`](/python/api/auth#apikeystrategy) for MRT (`Authorization` header).

#### create_webdav_auth <Badge type="info" text="method" /> {#resolvedconfigimpl-create-webdav-auth}

```python
def create_webdav_auth() -> AuthStrategy
```

Create the best available WebDAV auth strategy (basic preferred, else OAuth).

## Functions

### add_instance {#add-instance}

```python
def add_instance(instance: DwJsonConfig, *, path: str | None = None, project_directory: str | None = None, working_directory: str | None = None, set_active: bool = False) -> None
```

Add a new named instance to dw.json, creating the file if needed.

**Raises**

- `ValueError` — if the instance has no name or the name already exists.

### create_config_resolver {#create-config-resolver}

```python
def create_config_resolver() -> ConfigResolver
```

Create a [`ConfigResolver`](/python/api/config#configresolver) with the default sources.

### create_instance_from_config {#create-instance-from-config}

```python
def create_instance_from_config(config: NormalizedConfig, options: CreateB2CInstanceOptions | None = None) -> B2CInstance
```

Create a [`B2CInstance`](/python/api/instance#b2cinstance) from a [`NormalizedConfig`](/python/api/config#normalizedconfig).

Single source of truth for instance creation from resolved configuration —
used by both [`ResolvedConfigImpl.create_b2c_instance`](/python/api/config#resolvedconfigimpl-create-b2c-instance) and consumers such
as CLI commands. TLS options are included only when a certificate or
self-signed mode is configured. When `options` supplies a `redirect_uri` or
`open_browser`, they are injected into the OAuth config for browser flows.

**Raises**

- `ValueError` — if `config` has no `hostname`.

### create_instance_manager {#create-instance-manager}

```python
def create_instance_manager(sources: list[ConfigSource]) -> InstanceManager
```

Create an [`InstanceManager`](/python/api/config#instancemanager) with the given sources.

### find_dw_json {#find-dw-json}

```python
def find_dw_json(project_directory: str | None = None) -> str | None
```

Find dw.json by searching upward from `project_directory` (defaults to cwd).

### get_b2c_config_directory {#get-b2c-config-directory}

```python
def get_b2c_config_directory(*, config_directory: str | None = None, environment: dict[str, str] | None = None, home_directory: str | None = None, platform: str | None = None) -> str
```

Resolve the shared oclif-compatible B2C configuration directory.

### get_b2c_settings_path {#get-b2c-settings-path}

```python
def get_b2c_settings_path(*, config_directory: str | None = None, environment: dict[str, str] | None = None, home_directory: str | None = None, platform: str | None = None) -> str
```

Resolve the shared `settings.json` path.

### is_sensitive_config_field {#is-sensitive-config-field}

```python
def is_sensitive_config_field(field: str) -> bool
```

Return True when a field name holds a secret that should be masked.

### load_dw_json {#load-dw-json}

```python
def load_dw_json(*, instance: str | None = None, path: str | None = None, project_directory: str | None = None, working_directory: str | None = None) -> LoadDwJsonResult | None
```

Load configuration from a dw.json file (no upward directory search).

Keys are normalized to camelCase and the appropriate instance is selected.
Returns `None` if no file is found or the named instance is absent. Raises
on invalid JSON.

### load_full_dw_json {#load-full-dw-json}

```python
def load_full_dw_json(*, path: str | None = None, project_directory: str | None = None, working_directory: str | None = None) -> LoadFullDwJsonResult | None
```

Load the raw multi-config dw.json without selecting an instance.

Returns `None` if the file does not exist. Raises on invalid JSON.

### mask_config_value {#mask-config-value}

```python
def mask_config_value(value: str) -> str
```

Mask a secret, showing the first 4 chars when long enough to aid identification.

Matches the SDK logger convention (`<first4>...REDACTED`); values of 10 or
fewer characters are fully redacted.

### merge_project_environment {#merge-project-environment}

```python
def merge_project_environment(project_environment: dict[str, str] | None = None, ambient_environment: dict[str, str] | None = None) -> dict[str, str]
```

Merge project variables with the ambient environment (ambient wins).

### normalize_config_keys {#normalize-config-keys}

```python
def normalize_config_keys(raw: dict[str, Any]) -> dict[str, Any]
```

Normalize config keys to their canonical camelCase form.

Resolution order per key: alias table, then kebab->camelCase conversion. The
first value wins when multiple keys resolve to the same canonical name.
`None` values are dropped (mirrors the TS `undefined` skip) so absent
keys never shadow a later alias for the same canonical name.

### read_b2c_settings {#read-b2c-settings}

```python
def read_b2c_settings(*, config_directory: str | None = None, environment: dict[str, str] | None = None, home_directory: str | None = None, platform: str | None = None) -> dict[str, Any]
```

Read shared B2C settings. Missing or invalid files are treated as unset.

A relative `defaultConfigPath` is resolved against the settings directory;
a non-string/empty value is dropped with a warning.

### read_project_environment {#read-project-environment}

```python
def read_project_environment(project_directory: str | None = None) -> dict[str, str] | None
```

Read all variables from a project's `.env` file, or `None` if absent.

### redact_config_values {#redact-config-values}

```python
def redact_config_values(values: NormalizedConfig, *, unmask: bool = False) -> dict[str, Any]
```

Return a dict of config values with sensitive fields masked.

Fields whose value is `None` are omitted. When `unmask` is True secrets
are shown verbatim.

### remove_instance {#remove-instance}

```python
def remove_instance(name: str, *, path: str | None = None, project_directory: str | None = None, working_directory: str | None = None) -> None
```

Remove a named instance from dw.json.

**Raises**

- `FileNotFoundError` — if no dw.json exists.
- `ValueError` — when removing the root instance or a missing instance.

### resolve_config {#resolve-config}

```python
async def resolve_config(overrides: NormalizedConfig | None = None, options: ResolveConfigOptions | None = None) -> ResolvedConfigImpl
```

Resolve configuration and return a rich [`ResolvedConfigImpl`](/python/api/config#resolvedconfigimpl).

Resolution priority (highest to lowest): explicit overrides, `sources_before`,
default sources (dw.json, ~/.mobify, package.json), `sources_after`, and
globally-registered sources. Set `options.replace_default_sources` to omit
the defaults.

### resolve_library_entries {#resolve-library-entries}

```python
def resolve_library_entries(libraries: list[str | LibraryEntry] | None) -> list[LibraryEntry]
```

Normalize a `libraries` value to [`LibraryEntry`](/python/api/config#libraryentry) objects.

Bare strings become `LibraryEntry(id=..., site_library=False)`. Returns an
empty list when the input is `None`.

### save_dw_json {#save-dw-json}

```python
def save_dw_json(config: DwJsonMultiConfig, file_path: str) -> None
```

Save a dw.json to disk (2-space indent + trailing newline).

### set_active_instance {#set-active-instance}

```python
def set_active_instance(name: str, *, path: str | None = None, project_directory: str | None = None, working_directory: str | None = None) -> None
```

Set a named instance as the active default.

**Raises**

- `FileNotFoundError` — if no dw.json exists.
- `ValueError` — if the instance is not found.

### write_b2c_settings {#write-b2c-settings}

```python
def write_b2c_settings(settings: dict[str, Any], *, config_directory: str | None = None, environment: dict[str, str] | None = None, home_directory: str | None = None, platform: str | None = None) -> None
```

Write shared B2C settings atomically (mode 0o600, trailing newline).

## Attributes

### B2C_SETTINGS_FILENAME {#b2c-settings-filename}

```python
B2C_SETTINGS_FILENAME = 'settings.json'
```

### SENSITIVE_CONFIG_FIELDS {#sensitive-config-fields}

```python
SENSITIVE_CONFIG_FIELDS: frozenset[str] = frozenset({'certificate_passphrase', 'client_secret', 'jwt_passphrase', 'mrt_api_key', 'password', 'slas_client_secret'})
```

### DwJsonConfig {#dwjsonconfig}

```python
DwJsonConfig = dict[str, Any]
```

### DwJsonMultiConfig {#dwjsonmulticonfig}

```python
DwJsonMultiConfig = dict[str, Any]
```

### ResolvedB2CConfig {#resolvedb2cconfig}

```python
ResolvedB2CConfig = ResolvedConfigImpl
```

### global_config_source_registry {#global-config-source-registry}

```python
global_config_source_registry = ConfigSourceRegistry()
```