@dynamic-labs-sdk/client 1.2.1 → 1.4.0

package/dist/modules/walletOptionsCatalogue/buildInAppBrowserOptions/buildInAppBrowserOptions.d.ts

@@ -0,0 +1,22 @@
+import type { WalletBookSchema } from '../../legacyWalletBook/legacyWalletBook.types';
+import type { ConnectionOptionForWalletOption } from '../groupOptionsByWalletOption/groupOptionsByWalletOption';
+type BuildInAppBrowserOptionsParams = {
+    walletBook: WalletBookSchema;
+};
+/**
+ * Builds the `inAppBrowser` catalogue options from the wallet book. A wallet
+ * qualifies when it exposes a mobile in-app-browser URL — typically a
+ * `cb_url={{encodedDappURI}}`-style template the customer fills in with the
+ * current page URL before opening.
+ *
+ * Reuses the generic `shouldFilterWallet` rules — embedded sign-in methods
+ * and injected-only wallets are dropped — so the catalogue's notion of
+ * "external wallet" stays consistent across option types.
+ *
+ * @param params.walletBook - The fetched wallet book.
+ * @returns Tagged `inAppBrowser` options paired with their wallet option keys.
+ * @not-instrumented
+ */
+export declare const buildInAppBrowserOptions: ({ walletBook, }: BuildInAppBrowserOptionsParams) => ConnectionOptionForWalletOption[];
+export {};
+//# sourceMappingURL=buildInAppBrowserOptions.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildInAppBrowserOptions/buildInAppBrowserOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildInAppBrowserOptions.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/buildInAppBrowserOptions/buildInAppBrowserOptions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AAEtF,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,0DAA0D,CAAC;AAIhH,KAAK,8BAA8B,GAAG;IACpC,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,oBAElC,8BAA8B,KAAG,+BAA+B,EAyBlE,CAAC"}

package/dist/modules/walletOptionsCatalogue/buildInAppBrowserOptions/getInAppBrowserUrl/getInAppBrowserUrl.d.ts

@@ -0,0 +1,18 @@
+import type { WalletBookSchema } from '../../../legacyWalletBook/legacyWalletBook.types';
+type GetInAppBrowserUrlParams = {
+    wallet: WalletBookSchema['wallets'][string];
+};
+/**
+ * Returns the wallet's in-app browser URL template, preferring the v2
+ * field. `inAppBrowser` is deprecated but some wallet book entries
+ * still carry only the v1 value, so it acts as a fallback. Trailing
+ * `?? undefined` collapses the schema's `string | null` typing down to
+ * the `string | undefined` return contract.
+ *
+ * @param params.wallet - The wallet book wallet entry.
+ * @returns The in-app browser URL, or `undefined` if neither field is set.
+ * @not-instrumented
+ */
+export declare const getInAppBrowserUrl: ({ wallet, }: GetInAppBrowserUrlParams) => string | undefined;
+export {};
+//# sourceMappingURL=getInAppBrowserUrl.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildInAppBrowserOptions/getInAppBrowserUrl/getInAppBrowserUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getInAppBrowserUrl.d.ts","sourceRoot":"","sources":["../../../../../src/modules/walletOptionsCatalogue/buildInAppBrowserOptions/getInAppBrowserUrl/getInAppBrowserUrl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC;AAEzF,KAAK,wBAAwB,GAAG;IAC9B,MAAM,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;CAC7C,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,gBAE5B,wBAAwB,KAAG,MAAM,GAAG,SACoC,CAAC"}

package/dist/modules/walletOptionsCatalogue/buildInAppBrowserOptions/getInAppBrowserUrl/index.d.ts

@@ -0,0 +1,2 @@
+export { getInAppBrowserUrl } from './getInAppBrowserUrl';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildInAppBrowserOptions/getInAppBrowserUrl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/walletOptionsCatalogue/buildInAppBrowserOptions/getInAppBrowserUrl/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/modules/walletOptionsCatalogue/buildInAppBrowserOptions/index.d.ts

@@ -0,0 +1,2 @@
+export { buildInAppBrowserOptions } from './buildInAppBrowserOptions';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildInAppBrowserOptions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/buildInAppBrowserOptions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/modules/walletOptionsCatalogue/buildInstallationUrls/buildInstallationUrls.d.ts

@@ -0,0 +1,21 @@
+import type { WalletSchema } from '../../legacyWalletBook/legacyWalletBook.types';
+import type { InstallationUrls } from '../walletOptionsCatalogue.types';
+type BuildInstallationUrlsParams = {
+    wallet: WalletSchema;
+};
+/**
+ * Builds the install/download URL bag for a wallet book entry. Returns the
+ * concrete URLs assembled from each store's ID field — Play Store, App
+ * Store, Chrome Web Store, Firefox Add-ons, Edge Add-ons — plus the wallet's
+ * own `desktop.universal` / `desktop.native` URLs when set.
+ *
+ * Fields the wallet book does not carry are left undefined; callers should
+ * skip emitting an installation option for a wallet whose URL bag is empty.
+ *
+ * @param params.wallet - The wallet book entry.
+ * @returns The URL bag, omitting fields the wallet does not provide.
+ * @not-instrumented
+ */
+export declare const buildInstallationUrls: ({ wallet, }: BuildInstallationUrlsParams) => InstallationUrls;
+export {};
+//# sourceMappingURL=buildInstallationUrls.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildInstallationUrls/buildInstallationUrls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildInstallationUrls.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/buildInstallationUrls/buildInstallationUrls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAC;AAClF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAYxE,KAAK,2BAA2B,GAAG;IACjC,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,gBAE/B,2BAA2B,KAAG,gBAoBhC,CAAC"}

package/dist/modules/walletOptionsCatalogue/buildInstallationUrlsByWalletOptionKey/buildInstallationUrlsByWalletOptionKey.d.ts

@@ -0,0 +1,27 @@
+import type { WalletBookSchema } from '../../legacyWalletBook/legacyWalletBook.types';
+import type { InstallationUrls } from '../walletOptionsCatalogue.types';
+type BuildInstallationUrlsByWalletOptionKeyParams = {
+    walletBook: WalletBookSchema;
+};
+/**
+ * Collects install / download URLs for every wallet book entry that has
+ * at least one installable surface, keyed by the wallet option key the
+ * wallet groups under. The catalogue assembly step merges this map into
+ * the per-key wallet option shell so `WalletOption.installationUrls` is
+ * populated alongside (or instead of) `connectionOptions`.
+ *
+ * First-seen URLs win when multiple wallet book entries resolve to the
+ * same wallet option key — wallet book authors put the most accurate
+ * install links on the canonical entry, so the first-seen one is the
+ * right pick.
+ *
+ * Reuses the generic `shouldFilterWallet` rules so embedded wallets do
+ * not appear here either — they're not user-installable products.
+ *
+ * @param params.walletBook - The fetched wallet book.
+ * @returns A map from wallet option key to its install URL bag.
+ * @not-instrumented
+ */
+export declare const buildInstallationUrlsByWalletOptionKey: ({ walletBook, }: BuildInstallationUrlsByWalletOptionKeyParams) => Map<string, InstallationUrls>;
+export {};
+//# sourceMappingURL=buildInstallationUrlsByWalletOptionKey.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildInstallationUrlsByWalletOptionKey/buildInstallationUrlsByWalletOptionKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildInstallationUrlsByWalletOptionKey.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/buildInstallationUrlsByWalletOptionKey/buildInstallationUrlsByWalletOptionKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AAItF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAcxE,KAAK,4CAA4C,GAAG;IAClD,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,sCAAsC,oBAEhD,4CAA4C,KAAG,GAAG,CACnD,MAAM,EACN,gBAAgB,CA0BjB,CAAC"}

package/dist/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/buildUriDeeplinkOptions.d.ts

@@ -0,0 +1,28 @@
+import type { WalletBookSchema } from '../../legacyWalletBook/legacyWalletBook.types';
+import type { ConnectionOptionForWalletOption } from '../groupOptionsByWalletOption/groupOptionsByWalletOption';
+type BuildUriDeeplinkOptionsParams = {
+    walletBook: WalletBookSchema;
+};
+/**
+ * Builds the URI-deeplink catalogue options from a fetched wallet book.
+ * Applies the WalletConnect-specific eligibility filter
+ * (`shouldFilterWalletForWalletConnect`) so embedded wallets and entries
+ * without `sign_v2` support are excluded — same surface as
+ * `getWalletConnectCatalog`.
+ *
+ * Each emitted option carries the wallet's mobile deeplinks. Customers
+ * combine these with their chain's connection URI via
+ * `appendConnectionUriToDeeplink` to open the wallet's app:
+ *
+ * - `'walletConnect'`: mint via `connectWithWalletConnect<Chain>`.
+ * - `'metamaskSdkUri'`: mint via `connectWithMetaMaskUriEvm` or
+ *   `connectWithMetaMaskUriSolana`. Emitted only for the MetaMask
+ *   wallet entry — see `resolveUriConnectionType`.
+ *
+ * @param params.walletBook - The fetched wallet book.
+ * @returns Tagged options paired with their wallet option keys.
+ * @not-instrumented
+ */
+export declare const buildUriDeeplinkOptions: ({ walletBook, }: BuildUriDeeplinkOptionsParams) => ConnectionOptionForWalletOption[];
+export {};
+//# sourceMappingURL=buildUriDeeplinkOptions.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/buildUriDeeplinkOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildUriDeeplinkOptions.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/buildUriDeeplinkOptions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAEjB,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,0DAA0D,CAAC;AAiBhH,KAAK,6BAA6B,GAAG;IACnC,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,uBAAuB,oBAEjC,6BAA6B,KAAG,+BAA+B,EAgCjE,CAAC"}

package/dist/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/index.d.ts

@@ -0,0 +1,2 @@
+export { buildUriDeeplinkOptions } from './buildUriDeeplinkOptions';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/resolveUriConnectionType/index.d.ts

@@ -0,0 +1,2 @@
+export { resolveUriConnectionType } from './resolveUriConnectionType';
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/resolveUriConnectionType/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/resolveUriConnectionType/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/resolveUriConnectionType/resolveUriConnectionType.d.ts

@@ -0,0 +1,17 @@
+type ResolveUriConnectionTypeParams = {
+    walletOptionKey: string;
+};
+/**
+ * Picks the connection-option `type` discriminator for a wallet-book-
+ * derived URI deeplink option. MetaMask is steered toward its own
+ * MetaMask SDK URI connection extension (`metamaskSdkUri`) so we route
+ * customers off generic WalletConnect for that wallet; every other
+ * wallet uses the standard `walletConnect` discriminator.
+ *
+ * @param params.walletOptionKey - The resolved wallet option key.
+ * @returns The connection-option discriminator to emit.
+ * @not-instrumented
+ */
+export declare const resolveUriConnectionType: ({ walletOptionKey, }: ResolveUriConnectionTypeParams) => "metamaskSdkUri" | "walletConnect";
+export {};
+//# sourceMappingURL=resolveUriConnectionType.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/resolveUriConnectionType/resolveUriConnectionType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveUriConnectionType.d.ts","sourceRoot":"","sources":["../../../../../src/modules/walletOptionsCatalogue/buildUriDeeplinkOptions/resolveUriConnectionType/resolveUriConnectionType.ts"],"names":[],"mappings":"AAAA,KAAK,8BAA8B,GAAG;IACpC,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,yBAElC,8BAA8B,KAAG,gBAAgB,GAAG,eACc,CAAC"}

package/dist/modules/walletOptionsCatalogue/buildWalletOption/buildWalletOption.d.ts

@@ -0,0 +1,39 @@
+import type { WalletBookSchema } from '../../legacyWalletBook/legacyWalletBook.types';
+import type { WithWalletProviderDisplayOverride } from '../buildWithWalletProviderOptions/buildWithWalletProviderOptions';
+import type { InstallationUrls, WalletConnectionOption, WalletOption } from '../walletOptionsCatalogue.types';
+type BuildWalletOptionParams = {
+    connectionOptions: WalletConnectionOption[];
+    displayOverride?: WithWalletProviderDisplayOverride;
+    installationUrls?: InstallationUrls;
+    walletBook: WalletBookSchema;
+    walletOptionKey: string;
+};
+/**
+ * Assembles a `WalletOption` for a resolved wallet option key, populated
+ * with the connection options the transformers produced for it plus an
+ * optional install / download URL bag.
+ *
+ * Display merge rules (provider self-announced metadata wins where set):
+ *
+ * - `name`: `displayOverride.name` ?? wallet book group name ?? bare key.
+ * - `iconUrl`: `displayOverride.iconUrl` ?? wallet book group sprite URL ?? `''`.
+ * - `primaryColor`: wallet book group brand color only (providers do not
+ *   ship a primary color in their announcement metadata).
+ * - `installationUrls`: copied through if present.
+ *
+ * Why provider precedence: a registered wallet provider knows its own
+ * brand best (EIP-6963 / Wallet Standard / vendor SDK announcement is the
+ * wallet authoring its own identity). The wallet book fills in fields the
+ * announcement does not carry — currently only `primaryColor`.
+ *
+ * @param params.connectionOptions - The connections to attach to this wallet option.
+ * @param [params.displayOverride] - Provider-announced display info that overrides the wallet book's name and iconUrl.
+ * @param [params.installationUrls] - Install/download URL bag for this wallet.
+ * @param params.walletBook - The fetched wallet book.
+ * @param params.walletOptionKey - The wallet option key.
+ * @returns The constructed wallet option.
+ * @not-instrumented
+ */
+export declare const buildWalletOption: ({ connectionOptions, displayOverride, installationUrls, walletBook, walletOptionKey, }: BuildWalletOptionParams) => WalletOption;
+export {};
+//# sourceMappingURL=buildWalletOption.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildWalletOption/buildWalletOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildWalletOption.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/buildWalletOption/buildWalletOption.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACtF,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,kEAAkE,CAAC;AAC1H,OAAO,KAAK,EACV,gBAAgB,EAChB,sBAAsB,EACtB,YAAY,EACb,MAAM,iCAAiC,CAAC;AAEzC,KAAK,uBAAuB,GAAG;IAC7B,iBAAiB,EAAE,sBAAsB,EAAE,CAAC;IAC5C,eAAe,CAAC,EAAE,iCAAiC,CAAC;IACpD,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,UAAU,EAAE,gBAAgB,CAAC;IAC7B,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,iBAAiB,2FAM3B,uBAAuB,KAAG,YAe5B,CAAC"}

package/dist/modules/walletOptionsCatalogue/buildWithWalletProviderOptions/buildWithWalletProviderOptions.d.ts

@@ -0,0 +1,54 @@
+import type { DynamicClient } from '../../../client/types/DynamicClient';
+import type { WalletBookSchema } from '../../legacyWalletBook/legacyWalletBook.types';
+import type { WalletProviderRegistryEntry } from '../../wallets/walletProviderRegistry';
+import type { WithWalletProviderConnectionOption } from '../walletOptionsCatalogue.types';
+/**
+ * Display override sourced from a registered wallet provider's announced
+ * metadata (EIP-6963 / Wallet Standard / vendor SDK). The outer
+ * transformer applies these on top of any wallet book group entry — the
+ * provider knows its own brand best, so `name` + `iconUrl` here win
+ * over the wallet book's values when both exist.
+ */
+export type WithWalletProviderDisplayOverride = {
+    iconUrl: string;
+    name: string;
+};
+/**
+ * One `WithWalletProviderConnectionOption` paired with the wallet option
+ * key it should be bucketed under, plus the provider's self-announced
+ * display metadata. The outer transformer groups by `walletOptionKey` and
+ * uses `displayOverride` to build the wallet option shell, with provider
+ * precedence over the wallet book's display fields.
+ */
+export type WithWalletProviderOptionForWalletOption = {
+    displayOverride: WithWalletProviderDisplayOverride;
+    option: WithWalletProviderConnectionOption;
+    walletOptionKey: string;
+};
+type BuildWithWalletProviderOptionsParams = {
+    entries: WalletProviderRegistryEntry[];
+    walletBook: WalletBookSchema;
+};
+/**
+ * Converts each registered wallet provider entry into a
+ * `WithWalletProviderConnectionOption` paired with its target wallet
+ * option key and the provider's display override. Every classifiable
+ * entry surfaces in the catalogue; the outer transformer uses the
+ * carried `displayOverride` to override any wallet book branding for
+ * that key (provider self-announcement wins over book).
+ *
+ * Entries whose registration priority is not recognised by
+ * `classifyWithWalletProviderSource` are dropped from the catalogue and
+ * an error is logged so Datadog surfaces the unknown registration path —
+ * in production this should never happen, every chain extension is
+ * expected to register with one of the documented priorities.
+ *
+ * @param params.entries - Snapshot of the registry's entries.
+ * @param params.walletBook - The fetched wallet book.
+ * @param client - The Dynamic client (used for logging unclassifiable entries).
+ * @returns An array of tagged options, in input order.
+ * @not-instrumented
+ */
+export declare const buildWithWalletProviderOptions: ({ entries, walletBook }: BuildWithWalletProviderOptionsParams, client: DynamicClient) => WithWalletProviderOptionForWalletOption[];
+export {};
+//# sourceMappingURL=buildWithWalletProviderOptions.d.ts.map

package/dist/modules/walletOptionsCatalogue/buildWithWalletProviderOptions/buildWithWalletProviderOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildWithWalletProviderOptions.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/buildWithWalletProviderOptions/buildWithWalletProviderOptions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AACtF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAGxF,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,iCAAiC,CAAC;AAE1F;;;;;;GAMG;AACH,MAAM,MAAM,iCAAiC,GAAG;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,uCAAuC,GAAG;IACpD,eAAe,EAAE,iCAAiC,CAAC;IACnD,MAAM,EAAE,kCAAkC,CAAC;IAC3C,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,KAAK,oCAAoC,GAAG;IAC1C,OAAO,EAAE,2BAA2B,EAAE,CAAC;IACvC,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,8BAA8B,4BAChB,oCAAoC,UACrD,aAAa,KACpB,uCAAuC,EA0CzC,CAAC"}

package/dist/modules/walletOptionsCatalogue/classifyWithWalletProviderSource/classifyWithWalletProviderSource.d.ts

@@ -0,0 +1,31 @@
+import type { WalletProviderRegistryEntry } from '../../wallets/walletProviderRegistry';
+import type { WithWalletProviderSource } from '../walletOptionsCatalogue.types';
+type ClassifyWithWalletProviderSourceParams = {
+    entry: WalletProviderRegistryEntry;
+};
+/**
+ * Maps a registered wallet provider's registration priority to the
+ * `WithWalletProviderSource` value that should appear on its catalogue option.
+ *
+ * Priority mapping (set by each chain extension when it calls
+ * `registry.register`):
+ *
+ * - `WALLET_SDK` → `'sdk'` — branded SDKs wrapped by chain extensions
+ *   (Base Account via `@base-org/account`, MetaMask Connect, …).
+ * - `WALLET_SELF_ANNOUNCEMENT_STANDARD` → `'selfAnnounced'` — in-page
+ *   self-announcement standards (EIP-6963 on EVM, Wallet Standard on
+ *   Solana / Sui / …).
+ * - `WINDOW_INJECT` → `'windowInjected'` — legacy `window.*` injection.
+ *
+ * Returns `undefined` for providers whose registration priority does not
+ * correspond to a connectable external-wallet source — callers filter these
+ * out before emitting catalogue options.
+ *
+ * @param params.entry - The registry entry to classify.
+ * @returns The matching source, or `undefined` if this entry should not
+ *   surface a `withWalletProvider` option.
+ * @not-instrumented
+ */
+export declare const classifyWithWalletProviderSource: ({ entry, }: ClassifyWithWalletProviderSourceParams) => WithWalletProviderSource | undefined;
+export {};
+//# sourceMappingURL=classifyWithWalletProviderSource.d.ts.map

package/dist/modules/walletOptionsCatalogue/classifyWithWalletProviderSource/classifyWithWalletProviderSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifyWithWalletProviderSource.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/classifyWithWalletProviderSource/classifyWithWalletProviderSource.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACxF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAEhF,KAAK,sCAAsC,GAAG;IAC5C,KAAK,EAAE,2BAA2B,CAAC;CACpC,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,gCAAgC,eAE1C,sCAAsC,KACrC,wBAAwB,GACxB,SAgBH,CAAC"}

package/dist/modules/walletOptionsCatalogue/compareByRelevance/compareByRelevance.d.ts

@@ -0,0 +1,18 @@
+import type { WalletOption } from '../walletOptionsCatalogue.types';
+type CompareByRelevanceParams = {
+    a: WalletOption;
+    b: WalletOption;
+};
+/**
+ * Compares two wallet options for relevance ordering: priority-list index
+ * first, then alphabetical-by-name as the tie-break. Suitable for passing
+ * straight to `Array.prototype.sort`.
+ *
+ * @param params.a - First wallet option.
+ * @param params.b - Second wallet option.
+ * @returns Negative when `a` ranks first, positive when `b` ranks first.
+ * @not-instrumented
+ */
+export declare const compareByRelevance: ({ a, b, }: CompareByRelevanceParams) => number;
+export {};
+//# sourceMappingURL=compareByRelevance.d.ts.map

package/dist/modules/walletOptionsCatalogue/compareByRelevance/compareByRelevance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareByRelevance.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/compareByRelevance/compareByRelevance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE,KAAK,wBAAwB,GAAG;IAC9B,CAAC,EAAE,YAAY,CAAC;IAChB,CAAC,EAAE,YAAY,CAAC;CACjB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,cAG5B,wBAAwB,KAAG,MAS7B,CAAC"}

package/dist/modules/walletOptionsCatalogue/excludedWalletOptionKeys/excludedWalletOptionKeys.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Wallet option keys `getWalletOptionsCatalogue` drops before returning.
+ * Curated, product-level suppression.
+ *
+ * Example: Base Account SDK is the recommended entry point for
+ * Coinbase-managed users, so the legacy Coinbase Wallet entries are
+ * suppressed in favor of the SDK-backed `baseaccount` tile. Both the
+ * wallet book group key (`coinbase`) and the normalized display-name
+ * key (`coinbasewallet`) are listed so suppression holds regardless of
+ * how the resolver lands on a key.
+ *
+ * Used in: `getWalletOptionsCatalogue`.
+ */
+export declare const EXCLUDED_WALLET_OPTION_KEYS: ReadonlySet<string>;
+//# sourceMappingURL=excludedWalletOptionKeys.d.ts.map

package/dist/modules/walletOptionsCatalogue/excludedWalletOptionKeys/excludedWalletOptionKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"excludedWalletOptionKeys.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/excludedWalletOptionKeys/excludedWalletOptionKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,2BAA2B,EAAE,WAAW,CAAC,MAAM,CAG1D,CAAC"}

package/dist/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/findByNameMatch/findByNameMatch.d.ts

@@ -0,0 +1,21 @@
+import type { WalletBookSchema } from '../../../legacyWalletBook/legacyWalletBook.types';
+type FindByNameMatchParams = {
+    candidate: string;
+    walletBook: WalletBookSchema;
+};
+/**
+ * Looks for a wallet book entry whose `name` or `shortName` normalizes to
+ * the same string as `candidate`. Used as a fallback by
+ * `findWalletOptionKeyForProviderKey` for providers whose
+ * `walletProviderKey` strips down to a value that does not match any
+ * `walletBook.wallets` key directly (e.g. an extension whose display name
+ * happens to match the wallet's `shortName` instead of its book key).
+ *
+ * @param params.candidate - The lowercased, chain-suffix-stripped candidate.
+ * @param params.walletBook - The fetched wallet book.
+ * @returns The matching wallet book wallet key, or `undefined`.
+ * @not-instrumented
+ */
+export declare const findByNameMatch: ({ candidate, walletBook, }: FindByNameMatchParams) => string | undefined;
+export {};
+//# sourceMappingURL=findByNameMatch.d.ts.map

package/dist/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/findByNameMatch/findByNameMatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findByNameMatch.d.ts","sourceRoot":"","sources":["../../../../../src/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/findByNameMatch/findByNameMatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC;AAEzF,KAAK,qBAAqB,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AAKF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,+BAGzB,qBAAqB,KAAG,MAAM,GAAG,SAWnC,CAAC"}

package/dist/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/findWalletOptionKeyForProviderKey.d.ts

@@ -0,0 +1,44 @@
+import type { Chain } from '../../chain';
+import type { WalletBookSchema } from '../../legacyWalletBook/legacyWalletBook.types';
+import type { WalletProvider } from '../../wallets/walletProvider/walletProvider.types';
+type FindWalletOptionKeyForProviderKeyParams = {
+    chain: Chain;
+    walletBook: WalletBookSchema;
+    walletProvider: WalletProvider;
+};
+/**
+ * Resolves a registered wallet provider to the wallet option key it should
+ * be bucketed under. Always returns a key — providers with no wallet book
+ * match fall back to their self-announced `metadata.displayName`, so the
+ * catalogue surfaces them as self-described tiles instead of silently
+ * dropping them.
+ *
+ * Resolution order (each step short-circuits on first hit):
+ *
+ * 1. **Direct wallet book lookup with chain suffix** — try
+ *    `walletBook.wallets[normalizedWalletNameWithChain]` as-is. Wallet
+ *    book entries are inconsistent about whether they keep the chain
+ *    suffix (e.g. `metamaskevm`) or strip it (e.g. `metamask`), so try
+ *    the suffixed form first.
+ * 2. **Direct wallet book lookup without chain suffix** — strip the
+ *    suffix and retry.
+ * 3. **Name match heuristic with chain suffix** — scan
+ *    `walletBook.wallets` for an entry whose normalized `name` or
+ *    `shortName` equals the suffixed candidate.
+ * 4. **Name match heuristic without chain suffix** — same scan on the
+ *    stripped candidate.
+ * 5. **Display-name fallback** — derive a stable key from
+ *    `walletProvider.metadata.displayName` via
+ *    {@link normalizeWalletDisplayName}. Multi-chain registrations of the
+ *    same self-described wallet (e.g. Phantom on EVM and Solana) collapse
+ *    onto the same tile because each announces the same display name.
+ *
+ * @param params.chain - The provider's chain (used to strip the suffix).
+ * @param params.walletBook - The fetched wallet book.
+ * @param params.walletProvider - The registered wallet provider.
+ * @returns The wallet option key for this provider.
+ * @not-instrumented
+ */
+export declare const findWalletOptionKeyForProviderKey: ({ chain, walletBook, walletProvider, }: FindWalletOptionKeyForProviderKeyParams) => string;
+export {};
+//# sourceMappingURL=findWalletOptionKeyForProviderKey.d.ts.map

package/dist/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/findWalletOptionKeyForProviderKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findWalletOptionKeyForProviderKey.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/findWalletOptionKeyForProviderKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+CAA+C,CAAC;AAGtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mDAAmD,CAAC;AAKxF,KAAK,uCAAuC,GAAG;IAC7C,KAAK,EAAE,KAAK,CAAC;IACb,UAAU,EAAE,gBAAgB,CAAC;IAC7B,cAAc,EAAE,cAAc,CAAC;CAChC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,iCAAiC,2CAI3C,uCAAuC,KAAG,MAoC5C,CAAC"}

package/dist/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/resolveWalletOptionKey/resolveWalletOptionKey.d.ts

@@ -0,0 +1,20 @@
+import type { WalletBookSchema } from '../../../legacyWalletBook/legacyWalletBook.types';
+type ResolveWalletOptionKeyParams = {
+    fallback: string;
+    wallet: WalletBookSchema['wallets'][string];
+};
+/**
+ * Picks the wallet option (group) key for a wallet book wallet. The wallet
+ * book carries the group association under a few different field names
+ * (`group`, `chainGroup`, `walletGroup`) depending on the wallet's
+ * provenance — this helper centralises the lookup. When none of those
+ * fields are set, the wallet key itself acts as its own wallet option key.
+ *
+ * @param params.fallback - Wallet key to return if no group field is set.
+ * @param params.wallet - The wallet book wallet entry.
+ * @returns The resolved wallet option key.
+ * @not-instrumented
+ */
+export declare const resolveWalletOptionKey: ({ fallback, wallet, }: ResolveWalletOptionKeyParams) => string;
+export {};
+//# sourceMappingURL=resolveWalletOptionKey.d.ts.map

package/dist/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/resolveWalletOptionKey/resolveWalletOptionKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveWalletOptionKey.d.ts","sourceRoot":"","sources":["../../../../../src/modules/walletOptionsCatalogue/findWalletOptionKeyForProviderKey/resolveWalletOptionKey/resolveWalletOptionKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC;AAEzF,KAAK,4BAA4B,GAAG;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;CAC7C,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,0BAGhC,4BAA4B,KAAG,MACmC,CAAC"}

package/dist/modules/walletOptionsCatalogue/getConnectionOptionPriority/getConnectionOptionPriority.d.ts

@@ -0,0 +1,15 @@
+import type { WalletConnectionOption } from '../walletOptionsCatalogue.types';
+type GetConnectionOptionPriorityParams = {
+    option: WalletConnectionOption;
+};
+/**
+ * Returns the numeric priority of a `WalletConnectionOption` for sorting.
+ * Lower numbers rank first.
+ *
+ * @param params.option - The connection option to inspect.
+ * @returns The numeric priority — lower is better.
+ * @not-instrumented
+ */
+export declare const getConnectionOptionPriority: ({ option, }: GetConnectionOptionPriorityParams) => number;
+export {};
+//# sourceMappingURL=getConnectionOptionPriority.d.ts.map

package/dist/modules/walletOptionsCatalogue/getConnectionOptionPriority/getConnectionOptionPriority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getConnectionOptionPriority.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/getConnectionOptionPriority/getConnectionOptionPriority.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAkB9E,KAAK,iCAAiC,GAAG;IACvC,MAAM,EAAE,sBAAsB,CAAC;CAChC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,gBAErC,iCAAiC,KAAG,MACE,CAAC"}

package/dist/modules/walletOptionsCatalogue/getPriorityIndex/getPriorityIndex.d.ts

@@ -0,0 +1,16 @@
+import type { WalletOption } from '../walletOptionsCatalogue.types';
+type GetPriorityIndexParams = {
+    walletOption: WalletOption;
+};
+/**
+ * Returns the index of a wallet option in `PRIORITY_WALLET_KEYS`, or
+ * `Number.POSITIVE_INFINITY` when the wallet is not in the hand-curated
+ * priority list. Lower index = higher priority.
+ *
+ * @param params.walletOption - The wallet option to inspect.
+ * @returns Numeric priority index — lower is better.
+ * @not-instrumented
+ */
+export declare const getPriorityIndex: ({ walletOption, }: GetPriorityIndexParams) => number;
+export {};
+//# sourceMappingURL=getPriorityIndex.d.ts.map

package/dist/modules/walletOptionsCatalogue/getPriorityIndex/getPriorityIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPriorityIndex.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/getPriorityIndex/getPriorityIndex.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAEpE,KAAK,sBAAsB,GAAG;IAC5B,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,sBAE1B,sBAAsB,KAAG,MAI3B,CAAC"}

package/dist/modules/walletOptionsCatalogue/getWalletOptionsCatalogue/getWalletOptionsCatalogue.d.ts

@@ -0,0 +1,14 @@
+import type { GetWalletOptionsCatalogueParams, WalletOptionsCatalogue } from '../walletOptionsCatalogue.types';
+/**
+ * Returns the catalogue of external wallet options a user can sign in
+ * with through this client. Always includes installed wallet providers;
+ * pass `includeMobileOptions: true` to additionally surface
+ * WalletConnect, in-app-browser, and install links.
+ *
+ * @param [params] - Inclusion flag + ordering preference.
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ * @returns A promise that resolves to the wallet options catalogue.
+ * @not-instrumented
+ */
+export declare const getWalletOptionsCatalogue: (params?: GetWalletOptionsCatalogueParams, client?: import("../../../exports").DynamicClient) => Promise<WalletOptionsCatalogue>;
+//# sourceMappingURL=getWalletOptionsCatalogue.d.ts.map

package/dist/modules/walletOptionsCatalogue/getWalletOptionsCatalogue/getWalletOptionsCatalogue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getWalletOptionsCatalogue.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/getWalletOptionsCatalogue/getWalletOptionsCatalogue.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EACV,+BAA+B,EAG/B,sBAAsB,EACvB,MAAM,iCAAiC,CAAC;AAIzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,YAC5B,+BAA+B,wDAEtC,OAAO,CAAC,sBAAsB,CA6DhC,CAAC"}

package/dist/modules/walletOptionsCatalogue/groupOptionsByWalletOption/groupOptionsByWalletOption.d.ts

@@ -0,0 +1,49 @@
+import type { WithWalletProviderDisplayOverride } from '../buildWithWalletProviderOptions/buildWithWalletProviderOptions';
+import type { WalletConnectionOption } from '../walletOptionsCatalogue.types';
+/**
+ * A `connectionOption` tagged with the wallet option key it belongs under.
+ * Transformer outputs produce these; the catalogue groups them by
+ * `walletOptionKey` before building wallet option shells.
+ *
+ * `displayOverride` is set only by the `withWalletProvider` transformer,
+ * carrying the provider's self-announced `name` + `iconUrl`. The shell
+ * builder applies it on top of any wallet book entry — provider
+ * metadata wins over book branding.
+ */
+export type ConnectionOptionForWalletOption = {
+    displayOverride?: WithWalletProviderDisplayOverride;
+    option: WalletConnectionOption;
+    walletOptionKey: string;
+};
+/**
+ * Bucket of grouped options for a single wallet option key, plus the
+ * first-seen display override (if any). Returned by
+ * `groupOptionsByWalletOption` for the catalogue to feed into the shell
+ * builder.
+ */
+export type GroupedWalletOption = {
+    connectionOptions: WalletConnectionOption[];
+    displayOverride?: WithWalletProviderDisplayOverride;
+};
+type GroupOptionsByWalletOptionParams = {
+    options: ConnectionOptionForWalletOption[];
+};
+/**
+ * Buckets tagged connection options by their wallet option key. Preserves
+ * first-seen order so that the caller's choice of
+ * `walletOptionOrdering: 'relevance'` naturally inherits the upstream input
+ * order (wallet book order for walletConnect/inAppBrowser/installation,
+ * registry order for withWalletProvider).
+ *
+ * Carries through the first-seen `displayOverride` per wallet option
+ * key, so the shell builder can apply provider-announced metadata on
+ * top of any wallet book entry.
+ *
+ * @param params.options - The tagged options to group.
+ * @returns A map from wallet option key to its grouped option bucket,
+ *   iterable in first-seen order.
+ * @not-instrumented
+ */
+export declare const groupOptionsByWalletOption: ({ options, }: GroupOptionsByWalletOptionParams) => Map<string, GroupedWalletOption>;
+export {};
+//# sourceMappingURL=groupOptionsByWalletOption.d.ts.map

package/dist/modules/walletOptionsCatalogue/groupOptionsByWalletOption/groupOptionsByWalletOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"groupOptionsByWalletOption.d.ts","sourceRoot":"","sources":["../../../../src/modules/walletOptionsCatalogue/groupOptionsByWalletOption/groupOptionsByWalletOption.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,kEAAkE,CAAC;AAC1H,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE9E;;;;;;;;;GASG;AACH,MAAM,MAAM,+BAA+B,GAAG;IAC5C,eAAe,CAAC,EAAE,iCAAiC,CAAC;IACpD,MAAM,EAAE,sBAAsB,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,iBAAiB,EAAE,sBAAsB,EAAE,CAAC;IAC5C,eAAe,CAAC,EAAE,iCAAiC,CAAC;CACrD,CAAC;AAEF,KAAK,gCAAgC,GAAG;IACtC,OAAO,EAAE,+BAA+B,EAAE,CAAC;CAC5C,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B,iBAEpC,gCAAgC,KAAG,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAoBpE,CAAC"}

package/dist/modules/walletOptionsCatalogue/hasAnyConnectionOption/hasAnyConnectionOption.d.ts

@@ -0,0 +1,18 @@
+import type { WalletOption } from '../walletOptionsCatalogue.types';
+type HasAnyConnectionOptionParams = {
+    walletOption: WalletOption;
+};
+/**
+ * True when the wallet option has at least one connection — i.e. the user
+ * can sign in right now. Install-only wallet options surface in the
+ * catalogue too (they carry `installationUrls`) but have an empty
+ * `connectionOptions` array; this predicate distinguishes them from
+ * actually connectable wallets in the relevance sort.
+ *
+ * @param params.walletOption - The wallet option to inspect.
+ * @returns True when `connectionOptions` is non-empty.
+ * @not-instrumented
+ */
+export declare const hasAnyConnectionOption: ({ walletOption, }: HasAnyConnectionOptionParams) => boolean;
+export {};
+//# sourceMappingURL=hasAnyConnectionOption.d.ts.map