@microsoft/power-apps-native-host 0.2.22

package/lib/typescript/commonjs/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/commonjs/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';
+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

package/lib/typescript/commonjs/bridge/setupNativeHost.d.ts

@@ -0,0 +1,39 @@
+/*!
+ * power-apps-native-host — setupNativeHost
+ *
+ * Registers a NativePowerAppsBridge on the JS global (globalThis.powerAppsBridge)
+ * so the @microsoft/power-apps SDK picks it up automatically on the first data
+ * operation. The SDK reads globalThis.powerAppsBridge in getBridge() before
+ * falling back to the web DefaultPowerAppsBridge.
+ *
+ * Call this once at app root before any data operations. Re-calling with updated
+ * options (e.g. when connections change) is safe — it updates the existing bridge
+ * in-place without resetting the SDK's cached bridge promise.
+ */
+import type { NativeBridgeOptions } from './NativePowerAppsBridge';
+/**
+ * Registers a NativePowerAppsBridge for all @microsoft/power-apps SDK calls.
+ *
+ * On first call, creates a NativePowerAppsBridge and injects it into
+ * `globalThis.powerAppsBridge`. Subsequent calls update the bridge's options
+ * in-place so connection references and data sources can change without
+ * rebuilding the bridge (important because the SDK caches the bridge instance
+ * after first use).
+ *
+ * Idempotent with the same options reference — no-op if nothing changed.
+ *
+ * @example
+ * ```ts
+ * // App.tsx (root)
+ * import { setupNativeHost } from '@microsoft/power-apps-native-host';
+ *
+ * setupNativeHost({
+ *   getConnectorToken: (apiId) => msalClient.acquireToken({ resource: apiId }),
+ *   getDataverseToken: (datasetName) => msalClient.acquireToken({ resource: datasetName }),
+ *   dataSources: appManifest.dataSources,
+ *   connections: appManifest.connections,
+ * });
+ * ```
+ */
+export declare function setupNativeHost(options: NativeBridgeOptions): void;
+//# sourceMappingURL=setupNativeHost.d.ts.map

package/lib/typescript/commonjs/connections/ConnectionSetupScreen.d.ts

@@ -0,0 +1,107 @@
+/*!
+ * power-apps-native-host — ConnectionSetupScreen
+ *
+ * A ready-made React Native screen that drives the "create missing connections"
+ * flow before the Power Apps player is shown.
+ *
+ * Intended usage in an expo-router layout:
+ *
+ *   // app/(app)/_layout.tsx
+ *   import { ConnectionSetupScreen } from '@microsoft/power-apps-native-host';
+ *
+ *   if (missingConnectors.length > 0) {
+ *     return (
+ *       <ConnectionSetupScreen
+ *         missingConnectors={missingConnectors}    // from useConnectionRefs
+ *         schemaMap={schemaMap}
+ *         environmentId={powerConfig.environmentId}
+ *         region={powerConfig.region}
+ *         acquireToken={acquireToken}
+ *         onAllConnected={(resolvedIds) => {
+ *           // resolvedIds: Record<apiId, connectionId>
+ *           // Store them, then set missingConnectors = [] to unmount this screen.
+ *         }}
+ *         onSkip={() => { ... }}   // optional — hide skip button if not provided
+ *       />
+ *     );
+ *   }
+ *
+ * What the screen does for each missing connector, in order:
+ *   1. Shows connector name / description (fetched from API).
+ *   2. "Connect" button → calls createConnection → shows an in-app WebView
+ *      with the OAuth consent URL.
+ *   3. "Done" button in WebView header → calls checkNow() to confirm status.
+ *   4. On Connected → advances to the next missing connector.
+ *   5. When all connectors are resolved → calls onAllConnected.
+ *
+ * The component has zero production dependencies beyond react-native.
+ * It purposely does NOT depend on expo-router or any navigation library —
+ * the consuming app decides how to render it (full-screen, modal, etc.).
+ */
+import React from 'react';
+import type { ConnectorSchema } from '../platform/useConnectionRefs';
+export interface MissingConnectorEntry {
+    /** Connector API ID (e.g. "/providers/Microsoft.PowerApps/apis/shared_office365users"). */
+    apiId: string;
+    /** Local ref ID from power.config.json (for correlation). */
+    localRefId: string;
+}
+export interface ConnectionSetupScreenProps {
+    /**
+     * List of connectors that have no Connected connection.
+     * Each entry has the apiId and localRefId from the disambiguation result.
+     */
+    missingConnectors: MissingConnectorEntry[];
+    /**
+     * Connector schema map (from generate-connector-schemas / schemaMap).
+     * Used to map apiId → connectorId (short name) for API calls.
+     */
+    schemaMap: Record<string, ConnectorSchema>;
+    environmentId: string;
+    region?: string;
+    acquireToken: (scopes: string[]) => Promise<string | null>;
+    /**
+     * Called when all missing connections have been resolved.
+     * `resolvedIds` maps apiId → connectionId for all newly created connections.
+     */
+    onAllConnected: (resolvedIds: Record<string, string>) => void;
+    /**
+     * If provided, a "Skip" button is shown. Useful for non-blocking connection flows.
+     * The app should handle the case where connections remain unresolved.
+     */
+    onSkip?: () => void;
+    /**
+     * The ISV/wrap-app AAD client ID (from auth.config.json `msal.clientId`).
+     * Passed to `useConnectionSetup` so the ISV's service principal is granted
+     * access on each newly created connection, fixing the APIM 403 for
+     * third-party app tokens.
+     */
+    isvClientId?: string;
+    /**
+     * Optional custom renderer for the OAuth WebView.
+     * Receives the consent URL and a dismiss callback.
+     * If not provided, `Linking.openURL()` is used to open the URL in the system browser.
+     *
+     * @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;
+    /** Optional title override (default: "Set up connections"). */
+    title?: string;
+}
+/**
+ * Full-screen component that steps the user through creating each missing
+ * connection before the Power Apps player is launched.
+ *
+ * The screen works through missing connectors sequentially.  Once all are
+ * resolved `onAllConnected` fires and the parent app should unmount this
+ * component and proceed to launch the app.
+ */
+export declare function ConnectionSetupScreen({ missingConnectors, schemaMap, environmentId, region, acquireToken, isvClientId, onAllConnected, onSkip, renderOAuthWebView, title, }: ConnectionSetupScreenProps): React.JSX.Element;
+//# sourceMappingURL=ConnectionSetupScreen.d.ts.map

package/lib/typescript/commonjs/connections/disambiguate.d.ts

@@ -0,0 +1,43 @@
+/*!
+ * power-apps-native-host — connection disambiguation logic
+ *
+ * Pure function that matches power.config.json connectionReferences to the
+ * connection instances available in the user's Power Platform environment.
+ *
+ * Mirrors the core of ConnectionPipeline.matchConnectionsToUsages in the web
+ * host but is self-contained — it does not require IConnectionService or any
+ * other web-host dependency.
+ */
+import type { NativeConnectionInstance, NativeConnectionResolution } from './types';
+/**
+ * Disambiguate a set of connection references against the user's available
+ * connection instances.
+ *
+ * Rules (in priority order):
+ *  1. If exactly one `Connected` connection matches the reference apiId → resolved.
+ *  2. If zero connections match (or none are Connected) → missing.
+ *  3. If multiple Connected connections match → ambiguous (needs user pick).
+ *
+ * @param connectionReferences  The `connectionReferences` object from power.config.json,
+ *                              keyed by local reference ID.
+ * @param allConnectionsByApiId All connection instances fetched from the
+ *                              Power Platform connectivity API, keyed by
+ *                              connector apiId.
+ */
+export declare function disambiguateConnections(connectionReferences: Record<string, {
+    id: string;
+    dataSources: string[];
+}>, allConnectionsByApiId: Record<string, NativeConnectionInstance[]>): NativeConnectionResolution[];
+/**
+ * Extract the connection UUID from a raw connection name returned by the API.
+ *
+ * The API returns names like:
+ *   "shared_office365users/abc12345def6789012345678901234ab"  (connector-prefixed)
+ *   "abc12345def6789012345678901234ab"                        (bare UUID, no dashes)
+ *   "abc12345-def6-7890-1234-5678901234ab"                   (UUID with dashes)
+ *
+ * Returns the 32-char hex ID (dashes stripped) or the raw string if no UUID
+ * pattern is found.
+ */
+export declare function extractConnectionId(rawName: string): string;
+//# sourceMappingURL=disambiguate.d.ts.map

package/lib/typescript/commonjs/connections/types.d.ts

@@ -0,0 +1,91 @@
+/*!
+ * power-apps-native-host — connection disambiguation types
+ *
+ * Defines the native-host-specific types for connection resolution.  The web
+ * host equivalents live in @microsoft/power-apps-host, but the native host
+ * implements a lighter version that does not depend on IConnectionService.
+ */
+/**
+ * Resolved authorization state of a connection instance.
+ *
+ * - `Connected`     — platform status is Connected AND the ISV appid is in the connection ACL.
+ * - `NeedsAclGrant` — platform status is Connected but the ISV appid is missing from the ACL.
+ * - `NotConnected`  — platform status is anything other than Connected.
+ */
+export declare enum ConnectionStatus {
+    Connected = "Connected",
+    NeedsAclGrant = "NeedsAclGrant",
+    NotConnected = "NotConnected"
+}
+/** A single connection instance returned by the Power Platform connectivity API. */
+export interface NativeConnectionInstance {
+    /** Extracted connection UUID (hex, no dashes). */
+    id: string;
+    /** Full resource name from the API (connector-prefixed, e.g. "shared_office365users/abc123"). */
+    name: string;
+    /** Connector API identifier (e.g. "/providers/Microsoft.PowerApps/apis/shared_office365users"). */
+    apiId: string;
+    /** Resolved authorization status of this connection. */
+    status: ConnectionStatus;
+    /** Optional human-readable display name from the API. */
+    displayName?: string;
+}
+/**
+ * Result of attempting to match a single connection reference to an instance.
+ *
+ * - `resolved`  — exactly one Connected connection found; `connectionId` is set.
+ * - `missing`   — no connections found for this connector in the user's environment.
+ * - `ambiguous` — multiple Connected connections found; the app must pick one.
+ */
+export type NativeDisambiguationResult = {
+    kind: 'resolved';
+    connectionId: string;
+} | {
+    kind: 'missing';
+} | {
+    kind: 'ambiguous';
+    candidates: NativeConnectionInstance[];
+};
+/**
+ * Disambiguation result for a single connection reference (one apiId, possibly
+ * mapped to multiple data source names in the final connections map).
+ */
+export interface NativeConnectionResolution {
+    /** Local reference key in power.config.json connectionReferences (e.g. "office365users-1"). */
+    localRefId: string;
+    /** Connector API ID (e.g. "/providers/Microsoft.PowerApps/apis/shared_office365users"). */
+    apiId: string;
+    /** Data source names this reference covers (e.g. ["office365users"]). */
+    dataSources: string[];
+    result: NativeDisambiguationResult;
+}
+/**
+ * Callback invoked when a connection reference has multiple Connected candidate
+ * connections.  The consuming app should present a native picker UI (e.g. a
+ * bottom sheet) and return the selected connection ID.
+ *
+ * Return `null` to leave the connection unresolved (the SDK will receive an
+ * empty `connectionName` and data operations for that connector will fail).
+ *
+ * @param context.localRefId  — local reference key from power.config.json
+ * @param context.apiId       — connector API identifier
+ * @param context.candidates  — list of Connected connection instances to choose from
+ */
+export type OnDisambiguationNeeded = (context: {
+    localRefId: string;
+    apiId: string;
+    candidates: NativeConnectionInstance[];
+}) => Promise<string | null>;
+/**
+ * Callback invoked when the user has no connection for a required connector.
+ *
+ * The consuming app can redirect to the Power Apps maker portal or show an
+ * in-app connection setup flow.  Return `true` to indicate the user has
+ * created a connection and the hook should retry; return `false` to leave the
+ * connection unresolved.
+ */
+export type OnMissingConnection = (context: {
+    localRefId: string;
+    apiId: string;
+}) => Promise<boolean>;
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/commonjs/connections/useConnectionSetup.d.ts

@@ -0,0 +1,96 @@
+/*!
+ * power-apps-native-host — useConnectionSetup
+ *
+ * A hook that drives the "create missing connection" flow for a single connector.
+ *
+ * Usage pattern (in the ConnectionSetupScreen):
+ *
+ *   const setup = useConnectionSetup({
+ *     connectorId: 'shared_office365users',
+ *     environmentId,
+ *     region,
+ *     acquireToken,
+ *     onConnected: (connectionId) => { ... mark resolved, advance to next ... }
+ *   });
+ *
+ *   // Render setup.consentUrl in a WebView when setup.phase === 'oauth'
+ *   // Call setup.startCreate() to trigger connection creation
+ *   // Call setup.checkNow() to re-poll after WebView finishes
+ */
+import type { NativeConnectionInstance } from '../connections/types';
+/**
+ * The current phase of the connection setup flow for one connector.
+ *
+ * idle        — not yet started.
+ * creating    — POST in progress (showing a spinner).
+ * oauth       — connection created; OAuth consent URL is ready (show WebView).
+ * confirming  — WebView dismissed; polling for Connected status.
+ * connected   — connection is Connected; ready to proceed.
+ * error       — unrecoverable error; `errorMessage` is set.
+ */
+export type ConnectionSetupPhase = 'idle' | 'creating' | 'oauth' | 'confirming' | 'connected' | 'error';
+export interface UseConnectionSetupOptions {
+    /**
+     * Connector short name (e.g. "shared_office365users").
+     * Must match the connectorId used in the connectivity API (schema.name from schemaMap).
+     */
+    connectorId: string;
+    environmentId: string;
+    /** Cluster region (default "prod"). */
+    region?: string;
+    acquireToken: (scopes: string[]) => Promise<string | null>;
+    /** Called with the resolved `NativeConnectionInstance` when the connection is Connected. */
+    onConnected?: (instance: NativeConnectionInstance) => void;
+    /**
+     * The ISV/wrap-app AAD client ID (from auth.config.json `msal.clientId`).
+     * After connection creation, `addAadAppToConnectionAcl` is called to append
+     * the ISV's client ID to the connection ACE's AppIds list. This is required
+     * so that APIM accepts tokens bearing this appid at runtime (otherwise APIM
+     * returns 403 "missing connection ACL" for all third-party app tokens).
+     */
+    isvClientId?: string;
+    /**
+     * Redirect URL passed to the getConsentLink API call.
+     * Defaults to the standard native-client redirect accepted by Power Platform.
+     */
+    oauthRedirectUrl?: string;
+    /** Polling options forwarded to pollConnectionStatus. */
+    polling?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+    };
+}
+export interface UseConnectionSetupResult {
+    /** Current phase of the flow. */
+    phase: ConnectionSetupPhase;
+    /** OAuth consent URL — render in a WebView when phase === 'oauth'. */
+    consentUrl: string | null;
+    /** Error message when phase === 'error'. */
+    errorMessage: string | null;
+    /**
+     * Start the connection creation flow.
+     * Transitions: idle/error → creating → (oauth | connected | error).
+     */
+    startCreate: () => Promise<void>;
+    /**
+     * Call after the OAuth WebView is dismissed (or anytime during 'oauth' phase)
+     * to immediately poll the connection status instead of waiting for the next
+     * scheduled poll interval.
+     * Transitions: oauth → confirming → (connected | error).
+     */
+    checkNow: () => Promise<void>;
+    /**
+     * Call after the in-app browser session completes.
+     *
+     * If a `code` (CommitTokenCode) was returned in the redirect URL, it is
+     * POSTed to `confirmConsentCode` before polling. If no code is provided
+     * (custom-scheme redirect or dismiss), polling starts immediately.
+     *
+     * Transitions: oauth → confirming → (connected | error).
+     */
+    completeConsent: (code?: string) => Promise<void>;
+    /** Reset the flow back to idle (e.g., for a retry). */
+    reset: () => void;
+}
+export declare function useConnectionSetup({ connectorId, environmentId, region, acquireToken, onConnected, isvClientId, oauthRedirectUrl, polling, }: UseConnectionSetupOptions): UseConnectionSetupResult;
+//# sourceMappingURL=useConnectionSetup.d.ts.map

package/lib/typescript/commonjs/controls/FilePicker.d.ts

@@ -0,0 +1,65 @@
+import React from 'react';
+import { type StyleProp, type ViewStyle, type TextStyle } from 'react-native';
+export interface PickedFileInfo {
+    uri: string;
+    name: string;
+    mimeType: string;
+    /** File-compatible object ready for generated Dataverse upload methods. */
+    file: File;
+    /** Raw bytes of the file, ready to pass to lower-level upload APIs. */
+    bytes: Uint8Array;
+}
+export interface FilePickerProps {
+    label?: string;
+    /**
+     * The file name to display.
+     * - In view mode: the name of the existing Dataverse file.
+     * - In edit mode: the existing file name; falls back to the name of a newly picked file.
+     */
+    fileName?: string | null;
+    /**
+     * If provided, the file name row becomes tappable: calls this to obtain the
+     * raw bytes, writes them to the device cache, and opens the system share sheet.
+     */
+    onDownload?: () => Promise<Uint8Array>;
+    /** Share sheet dialog title. Defaults to `fileName`. */
+    shareTitle?: string;
+    /**
+     * If provided, a pick/replace button is shown.
+     * Called with the picked file and its pre-read bytes; the parent passes
+     * `bytes` directly to the upload service at save time.
+     */
+    onChange?: (file: PickedFileInfo) => void;
+    /** MIME type filter for the document picker. Defaults to all files. */
+    acceptedTypes?: string[];
+    /** Override the initial pick button label. */
+    pickButtonLabel?: string;
+    /** Override the replace button label after a file exists. */
+    replaceButtonLabel?: string;
+    /** Override the button label while the picked file is being read. */
+    readingLabel?: string;
+    /** Override the outer container (adds margin below by default). */
+    containerStyle?: StyleProp<ViewStyle>;
+    /** Override the label text style. */
+    labelStyle?: StyleProp<TextStyle>;
+    /** Override the file-name row container. */
+    fileRowStyle?: StyleProp<ViewStyle>;
+    /** Override the file-name text. */
+    fileNameStyle?: StyleProp<TextStyle>;
+    /** Override the pick/replace button container. */
+    buttonStyle?: StyleProp<ViewStyle>;
+    /** Override the pick/replace button text. */
+    buttonTextStyle?: StyleProp<TextStyle>;
+    /** Accent colour used for icons, borders and text. Defaults to `'#0078d4'`. */
+    accentColor?: string;
+}
+/**
+ * A unified file component for view and edit scenarios.
+ *
+ * - Pass `onDownload` alone for a read-only row that opens the share sheet on tap.
+ * - Pass `onChange` alone for a pick-only button (e.g. in an edit form).
+ * - Pass both to show the existing file name (tappable to download) alongside a
+ *   replace button — useful when the edit screen should also allow previewing.
+ */
+export declare function FilePicker({ label, fileName, onDownload, shareTitle, onChange, acceptedTypes, pickButtonLabel, replaceButtonLabel, readingLabel, containerStyle, labelStyle, fileRowStyle, fileNameStyle, buttonStyle, buttonTextStyle, accentColor, }: FilePickerProps): React.JSX.Element;
+//# sourceMappingURL=FilePicker.d.ts.map