@microsoft/power-apps-native-host 0.2.22

package/lib/typescript/commonjs/provider/PowerAppsHostProvider.d.ts

@@ -0,0 +1,123 @@
+/*!
+ * power-apps-native-host — PowerAppsHostProvider
+ *
+ * A React component that owns the full pre-launch pipeline:
+ *
+ *   1. Waits for the user to be signed in.
+ *   2. Resolves connection references via useConnectionRefs (with
+ *      disambiguation support).
+ *   3. If any connections are missing, renders ConnectionSetupScreen — which
+ *      the user MUST complete before the app opens.  There is no skip path.
+ *   4. Once all connections are resolved, initialises NativePowerAppsBridge
+ *      and renders children.
+ *
+ * The consuming app passes raw config (connectionReferences, schemaMap,
+ * databaseReferences) and never touches connection resolution logic.
+ *
+ *   <PowerAppsHostProvider
+ *     acquireToken={acquireToken}
+ *     isSignedIn={isSignedIn}
+ *     environmentId="..."
+ *     region="prod"
+ *     connectionReferences={powerConfig.connectionReferences}
+ *     schemaMap={schemaMap}
+ *     databaseReferences={powerConfig.databaseReferences}
+ *   >
+ *     <Slot />
+ *   </PowerAppsHostProvider>
+ */
+import React from 'react';
+import type { ConnectorSchema } from '../platform/useConnectionRefs';
+import type { DatabaseReference } from '../platform/PowerPlatformEnvironmentApi';
+import type { OnDisambiguationNeeded } from '../connections/types';
+export interface PowerAppsHostProviderProps {
+    /**
+     * Callback to acquire an access token for the given scopes.
+     * Typically provided by your MSAL/auth layer.
+     */
+    acquireToken: (scopes: string[]) => Promise<string | null>;
+    /**
+     * Whether the user is currently signed in.
+     * Connection resolution only runs when this is true.
+     */
+    isSignedIn: boolean;
+    /**
+     * PowerApps app GUID (from power.config.json `appId`).
+     * When set, connection references are fetched from the PowerApps RP
+     * `/apps/{appId}/launch` API at runtime instead of using the static
+     * `connectionReferences` prop.  Leave undefined during local development
+     * to fall back to the static `connectionReferences`.
+     */
+    appId?: string;
+    /** Power Platform environment GUID (from power.config.json). */
+    environmentId: string;
+    /**
+     * Routing region for the environment.
+     * @default 'prod'
+     */
+    region?: string;
+    /**
+     * The connectionReferences map from power.config.json.
+     * Shape: { [refId]: { id: string; dataSources: string[] } }
+     *
+     * NOTE: This prop must be referentially stable across renders (memoize it in
+     * the consumer). The bridge re-registration uses its identity as a cache key,
+     * so passing a fresh object literal every render forces continuous
+     * re-registration.
+     */
+    connectionReferences: Record<string, {
+        id: string;
+        dataSources: string[];
+    }>;
+    /**
+     * Connector schema map keyed by data source name.
+     * Generated automatically by generate-connector-schemas.
+     */
+    schemaMap: Record<string, ConnectorSchema>;
+    /**
+     * The databaseReferences map from power.config.json.
+     * Used to build CDS data sources for the bridge.
+     *
+     * NOTE: Like `connectionReferences`, pass a referentially stable value; an
+     * unstable identity each render triggers redundant bridge re-registration.
+     */
+    databaseReferences?: Record<string, DatabaseReference>;
+    /**
+     * Optional custom renderer for the OAuth consent WebView shown during
+     * connection creation.  If not provided, the system browser is used via
+     * Linking.openURL().
+     *
+     * @example
+     *   // Using react-native-webview:
+     *   renderOAuthWebView={(url, onDone) => (
+     *     <Modal visible animationType="slide">
+     *       <WebView source={{ uri: url }} />
+     *       <Button title="Done" onPress={onDone} />
+     *     </Modal>
+     *   )}
+     */
+    renderOAuthWebView?: (url: string, onDone: () => void) => React.ReactNode;
+    /**
+     * The ISV/wrap-app AAD client ID (from auth.config.json `msal.clientId`).
+     * When provided, the ISV's service principal is granted CanView access on
+     * each newly created connection, allowing APIM to accept tokens with this
+     * appid at runtime (prevents 403 "missing connection ACL" for third-party tokens).
+     */
+    isvClientId?: string;
+    /**
+     * Called when multiple Connected connections exist for the same connector.
+     * Present a native picker UI and return the chosen connectionId, or null to
+     * accept the first Connected connection as a fallback.
+     */
+    onDisambiguationNeeded?: OnDisambiguationNeeded;
+    children: React.ReactNode;
+}
+/**
+ * Initialises the NativePowerAppsBridge and manages the full pre-launch
+ * pipeline — connection resolution, disambiguation, and creation — before
+ * rendering children.
+ *
+ * Children are never rendered until all required connections are resolved.
+ */
+export declare function PowerAppsHostProvider({ acquireToken, isSignedIn, appId, environmentId, region, connectionReferences, schemaMap, databaseReferences, renderOAuthWebView, isvClientId, onDisambiguationNeeded, children, }: PowerAppsHostProviderProps): React.JSX.Element;
+//# sourceMappingURL=PowerAppsHostProvider.d.ts.map

package/lib/typescript/commonjs/provider/PowerAppsProvider.d.ts

@@ -0,0 +1,148 @@
+/*!
+ * power-apps-native-host — PowerAppsProvider
+ *
+ * A single provider that composes all infrastructure required to run a
+ * Power Apps canvas app inside an Expo shell:
+ *
+ *   GestureHandlerRootView
+ *   └── TamaguiProvider  (defaults to @tamagui/config/v3)
+ *       └── PortalProvider  (required by ToastViewport)
+ *           └── ToastProvider + ToastViewport
+ *               └── QueryClientProvider  (own QueryClient, wired to NetInfo + AppState)
+ *                   └── AuthProvider
+ *                       └── PowerAppsHostProvider  (connected via useAuth)
+ *                           └── children
+ *
+ * Usage:
+ *
+ *   <PowerAppsProvider
+ *     msalConfig={authConfig.msal}
+ *     powerConfig={powerConfig}
+ *     schemaMap={schemaMap}
+ *   >
+ *     <StatusBar style="auto" />
+ *     <Slot />
+ *   </PowerAppsProvider>
+ */
+import React from 'react';
+import { createTamagui } from '@tamagui/core';
+import type { AuthProviderProps } from '../auth/AuthContext';
+import type { PowerAppsHostProviderProps } from './PowerAppsHostProvider';
+import type { ConnectorSchema } from '../platform/useConnectionRefs';
+import type { DatabaseReference } from '../platform/PowerPlatformEnvironmentApi';
+import type { OnDisambiguationNeeded } from '../connections/types';
+import type { ThemeTokens } from '../theme/tokens';
+import type { ILogger } from '@microsoft/power-apps-native-common';
+/** Shape of power.config.json consumed by the provider. */
+export interface PowerConfig {
+    /**
+     * PowerApps app GUID written by `pac wrap` / the publish pipeline.
+     * When set, the host fetches connection references from the PowerApps RP
+     * `/apps/{appId}/launch` endpoint at runtime instead of reading the static
+     * `connectionReferences` object below.  Leave `null` (or omit) during local
+     * development — the static `connectionReferences` will be used as a fallback.
+     */
+    appId?: string | null;
+    environmentId?: string;
+    region?: string;
+    /**
+     * BAP environment `location` value (`environment.properties.location` from the
+     * Get Environments API). EU locations — `"europe"`, `"unitedkingdom"`,
+     * `"france"`, `"germany"`, `"italy"`, `"poland"`, `"norway"`, `"sweden"`,
+     * `"switzerland"` — route telemetry to the EU 1DS collector.
+     * Omit for the default global collector.
+     */
+    geoRegion?: string;
+    connectionReferences?: Record<string, {
+        id: string;
+        dataSources: string[];
+    }>;
+    databaseReferences?: Record<string, DatabaseReference>;
+    /**
+     * Allow additional keys — the offline SDK reads arbitrary fields from
+     * powerConfig. NOTE: offline activation is configured via the app's
+     * `offline-profile.json` (embedded into the Expo manifest as
+     * `extra.__offlineProfile`), NOT via a `powerConfig` field.
+     */
+    [key: string]: unknown;
+}
+type TamaguiConfig = ReturnType<typeof createTamagui>;
+export interface PowerAppsProviderProps {
+    /** MSAL configuration from auth.config.json (msal section). */
+    msalConfig: AuthProviderProps['msalConfig'];
+    /** Intune MAM configuration. Defaults to enabled in release builds. */
+    intuneConfig?: AuthProviderProps['intuneConfig'];
+    /** Contents of power.config.json. */
+    powerConfig: PowerConfig;
+    /**
+     * Connector schema map keyed by data source name.
+     * Generated automatically by generate-connector-schemas.
+     */
+    schemaMap: Record<string, ConnectorSchema>;
+    /**
+     * Tamagui design-system config.
+     * Defaults to the standard @tamagui/config/v3 preset.
+     */
+    tamaguiConfig?: TamaguiConfig;
+    /** Tamagui default colour theme. @default 'light' */
+    defaultTheme?: string;
+    /**
+     * Light-mode theme tokens for the built-in ThemeProvider.
+     * Defaults to the Power Platform green light palette.
+     * Pass a ThemeTokens object built from brand/tokens.ts to apply your brand.
+     */
+    theme?: ThemeTokens;
+    /**
+     * Dark-mode theme tokens for the built-in ThemeProvider.
+     * Defaults to the Power Platform green dark palette.
+     */
+    darkTheme?: ThemeTokens;
+    /**
+     * When `true`, the ThemeProvider automatically switches between `theme` and
+     * `darkTheme` based on the device colour scheme. @default true
+     */
+    followSystemTheme?: boolean;
+    /** See PowerAppsHostProviderProps.renderOAuthWebView. */
+    renderOAuthWebView?: PowerAppsHostProviderProps['renderOAuthWebView'];
+    /** See PowerAppsHostProviderProps.onDisambiguationNeeded. */
+    onDisambiguationNeeded?: OnDisambiguationNeeded;
+    /**
+     * App name used as `clientType` in the auto-wired 1DS telemetry provider.
+     * Appears in Kusto as the `clientType` column — use a stable
+     * `<Product><Variant>` string (e.g. `'PowerAppsDevPlayer'`).
+     * Ignored when `logger` is provided or `null`.
+     */
+    appName?: string;
+    /**
+     * Logger to use for host-package telemetry (auth, HTTP, platform APIs).
+     *
+     * - Omit (default): a `Logger` wired to `OneDsTelemetryProvider` (1DS JS)
+     *   is auto-created. `clusterCategory` is derived from `powerConfig.region`
+     *   (falls back to `'dev'`). This is the recommended path for all apps.
+     * - Pass an `ILogger` instance: that logger is used as-is, giving full
+     *   control over providers and severity.
+     * - Pass `null`: telemetry is explicitly disabled (opt-out). The host
+     *   logger becomes a no-op regardless of build variant.
+     */
+    logger?: ILogger | null;
+    /**
+     * Offline profile JSON — optional override.
+     * Primary source: SDK config plugin embeds offline-profile.json into the app
+     * manifest at prebuild time (read via expo-constants). This prop is only needed
+     * if you want to pass the profile programmatically (e.g., tests).
+     */
+    offlineProfile?: Record<string, unknown>;
+    children: React.ReactNode;
+}
+/**
+ * Top-level provider for Power Apps canvas apps running inside an Expo shell.
+ *
+ * Composes GestureHandlerRootView, TamaguiProvider, ToastProvider,
+ * QueryClientProvider, AuthProvider, and PowerAppsHostProvider into a single
+ * component, eliminating all provider boilerplate from the consuming app's
+ * root layout.
+ */
+export declare function PowerAppsProvider({ msalConfig, intuneConfig, powerConfig, schemaMap, tamaguiConfig, // override with app's tamagui.config.ts
+defaultTheme, theme, darkTheme, followSystemTheme, renderOAuthWebView, onDisambiguationNeeded, appName, logger: loggerProp, offlineProfile, children, }: PowerAppsProviderProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=PowerAppsProvider.d.ts.map

package/lib/typescript/commonjs/telemetry/index.d.ts

@@ -0,0 +1,48 @@
+/*!
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ *
+ * power-apps-native-host — package telemetry
+ *
+ * The shared logger singleton lives in `@microsoft/power-apps-native-common`
+ * (`getAppLogger` / `configureAppLogger`). This module re-exports those
+ * alongside the canonical host operation-name constants.
+ */
+export { getAppLogger, configureAppLogger } from '@microsoft/power-apps-native-common';
+/**
+ * Canonical operation names for host package telemetry.
+ * Follow the `PowerAppsHost.<Subsystem>.<Action>` convention so events are
+ * filterable in Kusto by prefix.
+ */
+export declare const HostOperationNames: {
+    /** MSAL PublicClientApplication.init() + initial account resolution. */
+    readonly AuthInit: "PowerAppsHost.Auth.Init";
+    /** Interactive sign-in (acquireToken interactive). */
+    readonly AuthSignIn: "PowerAppsHost.Auth.SignIn";
+    /** Sign-out (token cache clear + broker logout). */
+    readonly AuthSignOut: "PowerAppsHost.Auth.SignOut";
+    /** Silent token acquisition. Recorded only on failure. */
+    readonly AuthAcquireTokenSilentFailed: "PowerAppsHost.Auth.AcquireTokenSilent.Failed";
+    /** Intune MAM enrollment after sign-in. */
+    readonly AuthIntuneEnroll: "PowerAppsHost.Auth.Intune.Enroll";
+    /** Intune MAM unenrollment during sign-out. */
+    readonly AuthIntuneUnenroll: "PowerAppsHost.Auth.Intune.Unenroll";
+    /** SDK-originated HTTP request relayed through NativePowerAppsBridge. */
+    readonly BridgeHttpRequest: "PowerAppsHost.Bridge.HttpRequest";
+    /** Plugin call forwarded through NativePowerAppsBridge (verbose; also used for unhandled). */
+    readonly BridgeUnhandledPlugin: "PowerAppsHost.Bridge.PluginCall";
+    /** Connector/Dataverse token acquisition for the bridge. Recorded only on failure. */
+    readonly BridgeTokenAcquireFailed: "PowerAppsHost.Bridge.TokenAcquire.Failed";
+    /** Top-level React error boundary caught an unhandled JS error. */
+    readonly RuntimeUnhandledJsError: "PowerAppsHost.Runtime.UnhandledJsError";
+    /** Resolve Dataverse instanceUrl from Power Platform environment API. */
+    readonly PlatformFetchInstanceUrl: "PowerAppsHost.Platform.FetchInstanceUrl";
+    /** useConnectionRefs failed to resolve connections (recoverable). Recorded only on failure. */
+    readonly PlatformLoadConnectionsFailed: "PowerAppsHost.Platform.LoadConnections.Failed";
+    /** Create a new Power Platform connection. */
+    readonly PlatformCreateConnection: "PowerAppsHost.Platform.CreateConnection";
+    /** Resolve app connection references for the current launch. */
+    readonly PlatformResolveConnectionRefs: "PowerAppsHost.Platform.ResolveConnectionRefs";
+    /** Grant this app access to a Power Platform connection ACL. */
+    readonly PlatformConnectionAclGrant: "PowerAppsHost.Platform.ConnectionAclGrant";
+};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/theme/ThemeProvider.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ThemeProvider — distributes {@link ThemeTokens} through the component tree.
+ *
+ * `PowerAppsProvider` mounts this automatically. Use directly only when
+ * composing providers manually.
+ */
+import React from 'react';
+import { type ThemeTokens } from './tokens';
+export interface ThemeControl {
+    setTheme: (tokens: ThemeTokens) => void;
+    resetTheme: () => void;
+}
+export interface ThemeProviderProps {
+    theme?: ThemeTokens;
+    darkTheme?: ThemeTokens;
+    /** @default true */
+    followSystem?: boolean;
+    children: React.ReactNode;
+}
+export declare function ThemeProvider({ theme, darkTheme, followSystem, children, }: ThemeProviderProps): React.JSX.Element;
+/** Returns current {@link ThemeTokens} from the nearest ThemeProvider. */
+export declare function useThemeTokens(): ThemeTokens;
+/**
+ * Returns `{ setTheme, resetTheme }` for imperative theme overrides.
+ * Stable reference — does not re-render consumers on theme change.
+ */
+export declare function useThemeControl(): ThemeControl;
+export type { ThemeTokens } from './tokens';
+export { lightTheme, darkTheme } from './tokens';
+//# sourceMappingURL=ThemeProvider.d.ts.map

package/lib/typescript/commonjs/theme/tokens.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Theme token schema and built-in palettes for power-apps-native-host.
+ *
+ * Pass a custom {@link ThemeTokens} object to `PowerAppsProvider` to override
+ * the default Microsoft blue palette.
+ */
+export interface ThemeTokens {
+    surface0: string;
+    surface1: string;
+    surface2: string;
+    surface3: string;
+    surface4: string;
+    text0: string;
+    text1: string;
+    text2: string;
+    text3: string;
+    accentDeep: string;
+    accentBase: string;
+    accentSoft: string;
+    accentOnAccent: string;
+    isDark: boolean;
+}
+/** Microsoft blue light palette (default). */
+export declare const lightTheme: ThemeTokens;
+/** Microsoft blue dark palette (default). */
+export declare const darkTheme: ThemeTokens;
+//# sourceMappingURL=tokens.d.ts.map

package/lib/typescript/commonjs/utils/dataverseUtils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Utilities for reading local file:// URIs and converting them into the binary
+ * format expected by the Dataverse upload endpoint via NativePowerAppsBridge.
+ *
+ * Background:
+ *  - `fetch('file://')` fails silently on Android.
+ *  - `fetch('data:...')` throws "Network request failed" on Android.
+ *  - `new Blob([Uint8Array])` crashes Hermes ("ArrayBufferView not supported").
+ *  - NativePowerAppsBridge accepts `Uint8Array` and extracts `.buffer` as the
+ *    fetch body, which React Native sends as raw bytes correctly.
+ *
+ * Solution: read via `readAsStringAsync` (base64) → `atob` → `Uint8Array`.
+ */
+/**
+ * Read a local `file://` URI and return its contents as a `Uint8Array`.
+ * Safe on both Android and iOS.
+ */
+export declare function readFileAsUint8Array(uri: string): Promise<Uint8Array>;
+/**
+ * Detect the image MIME type from the first bytes of a base64-encoded string.
+ * Returns 'image/jpeg' as a safe default.
+ */
+export declare function detectImageMime(base64: string): string;
+/** Convert a base64 string into bytes suitable for Dataverse binary upload APIs. */
+export declare function base64ToUint8Array(base64: string): Uint8Array;
+/**
+ * Create a lightweight File-compatible object for generated Dataverse upload methods.
+ * React Native does not consistently provide a browser File implementation, but the
+ * generated services only require `name` and `arrayBuffer()`.
+ */
+export declare function createDataverseUploadFile(name: string, mimeType: string, bytes: Uint8Array): File;
+/** Create a File-compatible image object from Dataverse-style base64 image content. */
+export declare function base64ToDataverseUploadFile(base64: string, name?: string): File;
+/**
+ * Build a `data:<mime>;base64,<data>` URI from a raw base64 string returned
+ * by Dataverse for an image column.
+ */
+export declare function base64ToDataUri(base64: string): string;
+//# sourceMappingURL=dataverseUtils.d.ts.map

package/lib/typescript/commonjs/utils/isDevPlayer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * True when the JS bundle is running inside the Power Apps Dev Player shell.
+ *
+ * Two signals are combined to cover both execution paths:
+ *
+ * 1. `Constants.expoConfig.extra.isDevPlayer` — set in apps/dev-player/app.config.js.
+ *    Fires when the dev-player's **own** JS bundle is active (e.g. the launcher screen).
+ *
+ * 2. `NativeModules.PowerAppsDevLauncher` — the dev-player's Expo native module,
+ *    registered in the dev-player APK/IPA regardless of which JS bundle is loaded.
+ *    Fires when a template bundle is loaded via QR-code/URL into the dev-player shell,
+ *    because expo-constants then reflects the template's manifest (no isDevPlayer flag)
+ *    but the native module is still present in the host binary.
+ *
+ * Neither signal fires in a standalone release APK generated from the template, so
+ * `isDevPlayer` is false there and all debug logging is silenced.
+ */
+export declare const isDevPlayer: boolean;
+//# sourceMappingURL=isDevPlayer.d.ts.map

package/lib/typescript/module/ErrorBoundary.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+interface Props {
+    children: React.ReactNode;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+    componentStack: string | null;
+}
+/**
+ * Top-level React error boundary.
+ *
+ * Catches any unhandled JS exception thrown during rendering / lifecycle and
+ * displays a diagnostic screen.  All error details are written to the native
+ * log via debugLog so diagnostics stay consistent with the host package logger.
+ *
+ * Place this component at the very root of the component tree so it captures
+ * failures in any screen.
+ *
+ * Exported from power-apps-native-host so it can be used in the template and
+ * in any custom app without duplicating the implementation.
+ */
+export declare class ErrorBoundary extends React.Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): Partial<State>;
+    componentDidCatch(error: Error, info: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+export {};
+//# sourceMappingURL=ErrorBoundary.d.ts.map

package/lib/typescript/module/auth/AuthContext.d.ts

@@ -0,0 +1,57 @@
+/*!
+ * power-apps-native-host — AuthContext
+ *
+ * A generic MSAL auth provider built on power-apps-native-auth's
+ * PublicClientApplication.  Provides AuthProvider, useAuth, and the
+ * AuthState / AuthProviderProps types.
+ *
+ * Usage in the consuming Expo app:
+ *
+ *   <AuthProvider msalConfig={authConfig.msal}>
+ *     <PowerAppsHostProvider acquireToken={acquireToken} ...>
+ *       {children}
+ *     </PowerAppsHostProvider>
+ *   </AuthProvider>
+ */
+import React from 'react';
+import type { MsalAuthConfig, IntuneConfig } from '@microsoft/power-apps-native-auth';
+export interface AuthState {
+    isLoading: boolean;
+    isAuthReady: boolean;
+    isSignedIn: boolean;
+    /**
+     * True only when a real MSAL account is present (a usable token can be
+     * acquired). Unlike `isSignedIn`, this is NOT inflated by `noAuthMode`
+     * (login-bypassed / demo sessions report `isSignedIn: true` but have no
+     * account and `acquireToken` always returns null). Offline engagement must
+     * gate on this — engaging offline without a token spins the SDK orchestrator
+     * in a perpetual "waiting-for-auth" retry loop.
+     */
+    hasRealAccount: boolean;
+    error: Error | null;
+    acquireToken: (scopes: string[]) => Promise<string | null>;
+    signIn: () => Promise<void>;
+    signOut: () => Promise<void>;
+}
+export interface AuthProviderProps {
+    /**
+     * MSAL configuration from the consuming app's auth.config.json (msal section).
+     * `useBroker` defaults to `!__DEV__` when omitted — broker is enabled
+     * automatically in release builds and disabled in the dev client.
+     */
+    msalConfig: MsalAuthConfig;
+    /**
+     * Intune MAM configuration. `enabled` defaults to `!__DEV__` when omitted,
+     * so MAM enrollment is active in release builds and skipped in the dev client.
+     * Pass explicitly only to override the default (e.g. in tests).
+     */
+    intuneConfig?: IntuneConfig;
+    children: React.ReactNode;
+}
+export declare function AuthProvider({ msalConfig, intuneConfig, children }: AuthProviderProps): React.JSX.Element;
+/**
+ * Returns the current auth state from the nearest <AuthProvider>.
+ * Must be called within the AuthProvider tree.
+ */
+export declare function useAuth(): AuthState;
+//# sourceMappingURL=AuthContext.d.ts.map

package/lib/typescript/module/bridge/NativePowerAppsBridge.d.ts

@@ -0,0 +1,112 @@
+/*!
+ * power-apps-native-host — NativePowerAppsBridge
+ *
+ * A PowerAppsBridge implementation for React Native that handles all plugin
+ * calls in-process: auth tokens are supplied by the host app via callbacks,
+ * and HTTP is performed with the global `fetch` (built into RN 0.60+).
+ *
+ * This file mirrors the bridge in the SDK but lives here so the package can
+ * be used without patching the published @microsoft/power-apps tarball.
+ */
+import type { NativeConnectionInstance } from '../connections/types.js';
+export type CdsDataSourceConfig = Record<string, unknown>;
+/**
+ * Per-connection-reference data keyed by data source name
+ * (e.g. "commondataserviceforapps", "office365users").
+ * Returned to the SDK for AppPowerAppsClientPlugin.loadAppConnectionsAsync_v2
+ * and AppPowerAppsClientPlugin.loadNonCompositeConnectionsAsync.
+ */
+export interface AppConnectionReference {
+    /** Connector API ID, e.g. "/providers/Microsoft.PowerApps/apis/shared_commondataserviceforapps" */
+    apiId: string;
+    /** Connector runtime base URL (environment-specific). */
+    runtimeUrl: string;
+    /** Per-user connection identifier assigned by Power Platform. */
+    connectionName: string;
+    /** Dataset name (e.g. Dataverse org URL for CDS). */
+    datasetName?: string;
+    [key: string]: unknown;
+    instances?: NativeConnectionInstance[];
+}
+/** @deprecated Use AppConnectionReference */
+export type AppConnection = AppConnectionReference;
+/**
+ * Build a connection-references map (keyed by data source name) from the
+ * `connectionReferences` section of power.config.json.
+ *
+ * Each entry from power.config.json looks like:
+ *   { id: "/providers/Microsoft.PowerApps/apis/shared_XXX", dataSources: ["XXX"], ... }
+ *
+ * The resulting map shape is what the SDK expects for loadAppConnectionsAsync_v2:
+ *   { XXX: { apiId, runtimeUrl, connectionName, datasetName } }
+ *
+ * `runtimeUrl` and `connectionName` default to empty strings — they must be
+ * populated at runtime from the Power Platform connections API for the SDK to
+ * make actual connector API calls.
+ *
+ * @param powerConfigConnectionReferences - The `connectionReferences` object
+ *   from power.config.json.
+ */
+export declare function buildConnectionReferences(powerConfigConnectionReferences: Record<string, {
+    id: string;
+    dataSources: string[];
+    [key: string]: unknown;
+}>): Record<string, AppConnectionReference>;
+export type NativeBridgeOptions = {
+    /**
+     * Return an auth token scoped to a connector API endpoint.
+     * @param apiId - Connection API identifier (e.g. "shared_sharepointonline").
+     */
+    getConnectorToken(apiId: string): Promise<string>;
+    /**
+     * Return an auth token for a Dataverse org URL.
+     * @param datasetName - The Dataverse org URL used as the OAuth resource.
+     */
+    getDataverseToken(datasetName: string): Promise<string>;
+    /** Data-source configs from the app manifest / Power Apps server response. */
+    dataSources: CdsDataSourceConfig[];
+    /**
+     * Connection references keyed by data source name
+     * (e.g. { commondataserviceforapps: { apiId, runtimeUrl, connectionName } }).
+     * Returned to the SDK for loadAppConnectionsAsync_v2 and
+     * loadNonCompositeConnectionsAsync. Build from power.config.json's
+     * connectionReferences using buildConnectionReferences().
+     */
+    connections: Record<string, AppConnectionReference>;
+};
+export declare class NativePowerAppsBridge {
+    private _options;
+    constructor(_options: NativeBridgeOptions);
+    /**
+     * Updates the bridge's options in-place.
+     *
+     * Call this when connection references or data sources change (e.g. after
+     * a new connection is created) without recreating the bridge. The SDK caches
+     * the bridge instance after the first data operation, so replacing the bridge
+     * via globalThis would have no effect — mutating options is the correct path.
+     */
+    updateOptions(options: NativeBridgeOptions): void;
+    initialize(): Promise<void>;
+    /**
+     * Hermes-safe body construction. Returns the raw body value so that
+     * _sendHttpAsync can pass it directly to fetch without any Blob wrapping.
+     *
+     * The web-player's RuntimeDataClient wraps all bodies in `new Blob([...])`,
+     * which Hermes does not support for ArrayBuffer / TypedArray inputs.
+     * Implementing this hook on the bridge bypasses that wrapping entirely.
+     */
+    createRequestBody(config: {
+        body?: string | Uint8Array | ArrayBuffer | Blob;
+        headers?: {
+            [key: string]: string;
+        };
+    }): Blob | string | Uint8Array | ArrayBuffer;
+    executePluginAsync<T = unknown>(pluginName: string, pluginAction: string, params: unknown[]): Promise<T>;
+    /**
+     * Calls fetch and returns the result in the exact shape expected by
+     * RuntimeDataClient._executeRequest:
+     *   [{ status: number; headers: Record<string, string> }, ArrayBuffer]
+     */
+    private _sendHttpAsync;
+}
+//# sourceMappingURL=NativePowerAppsBridge.d.ts.map