@microsoft/power-apps-native-host 0.2.22

package/lib/typescript/module/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.js';
+/**
+ * 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/module/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.js';
+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/module/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.js';
+/**
+ * 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/module/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/module/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.js';
+/**
+ * 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/module/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

package/lib/typescript/module/controls/ImagePicker.d.ts

@@ -0,0 +1,76 @@
+import React from 'react';
+import { type StyleProp, type ViewStyle, type TextStyle, type ImageStyle } from 'react-native';
+import * as ExpoImagePicker from 'expo-image-picker';
+export interface PickedImageInfo {
+    uri: string;
+    name: string;
+    mimeType: string;
+    base64: string;
+    /** File-compatible object ready for generated Dataverse upload methods. */
+    file: File;
+    /** Raw bytes of the image, ready to pass to lower-level upload APIs. */
+    bytes: Uint8Array;
+}
+export interface ImagePickerProps {
+    label?: string;
+    /**
+     * Base64 string from Dataverse (the `cr_assetimage` thumbnail).
+     * The component builds the preview data URI internally.
+     * Pass `null` / `undefined` when there is no existing image.
+     */
+    initialBase64?: string | null;
+    /**
+     * Called when the user picks a new image.
+     * Receives the base64-encoded string, ready to include in a Dataverse PATCH body.
+     * Called with `null` if the user clears the image (future use).
+     */
+    onChange?: (base64: string | null) => void;
+    /** Called when the user picks a new image. Includes a generated-service-ready File object. */
+    onImageChange?: (image: PickedImageInfo | null) => void;
+    /** File name used when the selected image asset does not provide one. */
+    imageFileName?: string;
+    /** JPEG/PNG compression quality passed to expo-image-picker. Defaults to 0.8. */
+    quality?: number;
+    /** Enable the platform image editor after selecting or taking a photo. Defaults to false. */
+    allowsEditing?: boolean;
+    /** Android-only crop aspect ratio used when `allowsEditing` is true. */
+    aspect?: [number, number];
+    /** Android-only crop shape used when `allowsEditing` is true. */
+    cropShape?: ExpoImagePicker.CropShape;
+    /** Include EXIF metadata in the Expo picker asset. Defaults to false. */
+    exif?: boolean;
+    /** Use Android's legacy media picker. Defaults to false. */
+    legacy?: boolean;
+    /** Override the camera button label. */
+    cameraButtonLabel?: string;
+    /** Override the initial image-library button label. */
+    selectButtonLabel?: string;
+    /** Override the image-library button label after an image exists. */
+    changeButtonLabel?: string;
+    /** Override the button label while the picked image 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 button row container. */
+    buttonRowStyle?: StyleProp<ViewStyle>;
+    /** Override each button container. */
+    buttonStyle?: StyleProp<ViewStyle>;
+    /** Override each button text. */
+    buttonTextStyle?: StyleProp<TextStyle>;
+    /** Override the image preview. */
+    previewStyle?: StyleProp<ImageStyle>;
+    /** Accent colour used for icons, borders and text. Defaults to `'#0078d4'`. */
+    accentColor?: string;
+}
+/**
+ * A self-contained image picker that shows a preview and lets the user
+ * choose a new image from the library. Works on Android and iOS.
+ *
+ * - Existing images are seeded from a Dataverse base64 string via `initialBase64`.
+ * - On pick, the image is returned as base64 for legacy callers and as a
+ *   File-compatible object for generated Dataverse upload methods.
+ */
+export declare function ImagePicker({ label, initialBase64, onChange, containerStyle, labelStyle, buttonRowStyle, buttonStyle, buttonTextStyle, previewStyle, accentColor, onImageChange, imageFileName, quality, allowsEditing, aspect, cropShape, exif, legacy, cameraButtonLabel, selectButtonLabel, changeButtonLabel, readingLabel, }: ImagePickerProps): React.JSX.Element;
+//# sourceMappingURL=ImagePicker.d.ts.map

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

@@ -0,0 +1,42 @@
+/*!
+ * power-apps-native-host
+ * React Native host integration for @microsoft/power-apps
+ *
+ */
+export { NativePowerAppsBridge } from './bridge/NativePowerAppsBridge.js';
+export type { NativeBridgeOptions, CdsDataSourceConfig, AppConnection, AppConnectionReference } from './bridge/NativePowerAppsBridge.js';
+export { buildConnectionReferences } from './bridge/NativePowerAppsBridge.js';
+export { setupNativeHost } from './bridge/setupNativeHost.js';
+export { AuthProvider, useAuth } from './auth/AuthContext.js';
+export type { AuthState, AuthProviderProps } from './auth/AuthContext.js';
+export type { AuthConfig, MsalAuthConfig, IntuneConfig } from '@microsoft/power-apps-native-auth';
+export { PowerAppsHostProvider } from './provider/PowerAppsHostProvider.js';
+export type { PowerAppsHostProviderProps } from './provider/PowerAppsHostProvider.js';
+export { PowerAppsProvider } from './provider/PowerAppsProvider.js';
+export type { PowerAppsProviderProps, PowerConfig } from './provider/PowerAppsProvider.js';
+export { fetchInstanceUrl, buildCdsDataSources, buildEnvironmentEndpoint, POWER_PLATFORM_API_SCOPE } from './platform/PowerPlatformEnvironmentApi.js';
+export type { LinkedEnvironmentMetadata, DatabaseReference, DatabaseReferenceDataSource } from './platform/PowerPlatformEnvironmentApi.js';
+export { useConnectionRefs } from './platform/useConnectionRefs.js';
+export type { UseConnectionRefsOptions, UseConnectionRefsResult, ConnectorSchema } from './platform/useConnectionRefs.js';
+export { fetchConnectorMetadata, fetchConnectionsForConnector, createConnection, pollConnectionStatus, confirmConsentCode, fetchAppLaunchData, } from './platform/PowerPlatformConnectionApi.js';
+export type { ConnectorMetadata, CreateConnectionResult, AppLaunchResult, } from './platform/PowerPlatformConnectionApi.js';
+export { disambiguateConnections, extractConnectionId } from './connections/disambiguate.js';
+export type { NativeConnectionInstance, NativeConnectionResolution, NativeDisambiguationResult, OnDisambiguationNeeded, OnMissingConnection, } from './connections/types.js';
+export { useConnectionSetup } from './connections/useConnectionSetup.js';
+export type { ConnectionSetupPhase, UseConnectionSetupOptions, UseConnectionSetupResult, } from './connections/useConnectionSetup.js';
+export { ConnectionSetupScreen } from './connections/ConnectionSetupScreen.js';
+export type { MissingConnectorEntry, ConnectionSetupScreenProps, } from './connections/ConnectionSetupScreen.js';
+export { ThemeProvider, useThemeTokens, useThemeControl } from './theme/ThemeProvider.js';
+export type { ThemeProviderProps, ThemeControl } from './theme/ThemeProvider.js';
+export { lightTheme, darkTheme } from './theme/tokens.js';
+export type { ThemeTokens } from './theme/tokens.js';
+export { FilePicker } from './controls/FilePicker.js';
+export type { FilePickerProps, PickedFileInfo } from './controls/FilePicker.js';
+export { ImagePicker } from './controls/ImagePicker.js';
+export type { ImagePickerProps, PickedImageInfo } from './controls/ImagePicker.js';
+export { isDevPlayer } from './utils/isDevPlayer.js';
+export { base64ToDataverseUploadFile, base64ToUint8Array, createDataverseUploadFile, } from './utils/dataverseUtils.js';
+export { getAppLogger, configureAppLogger, HostOperationNames } from './telemetry/index.js';
+export type { ILogger } from '@microsoft/power-apps-native-common';
+export { ErrorBoundary } from './ErrorBoundary.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * Conditional debug logger for power-apps-native-host.
+ *
+ * Debug logs (debugLog / debugWarn) are only emitted when the JS bundle
+ * is running inside the Power Apps Dev Player (detected via
+ * `Constants.expoConfig.extra.isDevPlayer`).  They are silenced in release
+ * APKs generated from the template so the production log stream stays clean.
+ */
+export declare function debugLog(...args: unknown[]): void;
+export declare function debugWarn(...args: unknown[]): void;
+//# sourceMappingURL=logger.d.ts.map

package/lib/typescript/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}