@microsoft/power-apps-native-host 0.3.3 → 0.5.1

package/lib/module/target/PowerAppsTargetBootstrap.js

@@ -0,0 +1,529 @@
+"use strict";
+
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import { ActivityIndicator, Pressable, Text, View } from 'react-native';
+import * as SecureStore from 'expo-secure-store';
+import { AuthProvider, useAuth } from '../auth/AuthContext';
+import { fetchAccessibleEnvironments } from "../platform/DataverseGlobalDiscoveryApi.js";
+import { areDataverseOriginAliases, canonicalizeDataverseOrigin } from "../platform/CanvasAppResolution.js";
+import { resolveCanvasApp } from "../platform/CanvasAppResolutionApi.js";
+import { globalDiscoveryScope } from "../platform/GlobalDiscovery.js";
+import { connectionUserConsentScope, powerPlatformScope } from "../platform/PowerPlatformEnvironmentApi.js";
+import { TargetRuntimeError } from "./errors.js";
+import { isTenantAllowed, MULTI_TENANT_AUTHORITY } from "../config/tenantMode.js";
+import { PowerAppsExperienceBoundary } from "./PowerAppsExperience.js";
+import { DefaultPowerAppsExperience } from "./DefaultPowerAppsExperience.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const TARGET_STORAGE_KEY = 'microsoft.power-apps-native-host.selected-target.v1';
+const EMPTY_ENVIRONMENT_STABILITY_MS = 500;
+function LoadingScreen({
+  message
+}) {
+  return /*#__PURE__*/_jsxs(View, {
+    style: {
+      flex: 1,
+      alignItems: 'center',
+      justifyContent: 'center',
+      gap: 12,
+      padding: 24
+    },
+    children: [/*#__PURE__*/_jsx(ActivityIndicator, {
+      size: "large"
+    }), /*#__PURE__*/_jsx(Text, {
+      style: {
+        color: '#605E5C'
+      },
+      children: message
+    })]
+  });
+}
+function toEnvironmentSummary(target) {
+  return {
+    id: target.id,
+    label: target.label
+  };
+}
+function toExperienceError(error) {
+  return {
+    code: error.code,
+    message: error.userMessage,
+    retryable: error.retryable
+  };
+}
+function TargetRuntime({
+  target,
+  generation,
+  msalConfig,
+  isCurrent,
+  children,
+  onBack,
+  experienceComponent
+}) {
+  const auth = useAuth();
+  const [state, setState] = useState('authenticating');
+  const [resolvedTarget, setResolvedTarget] = useState();
+  const [error, setError] = useState();
+  const [retry, setRetry] = useState(0);
+  useEffect(() => {
+    if (!auth.isAuthReady || !auth.account) return;
+    let active = true;
+    setState('resolving');
+    setError(undefined);
+    void (async () => {
+      try {
+        const dataverseApiUrl = target.dataverseApiUrl;
+        const resolved = await resolveCanvasApp(target, dataverseApiUrl, auth.acquireToken, {
+          value: generation,
+          isCurrent
+        });
+        if (!active || !isCurrent(generation)) return;
+        setResolvedTarget(resolved);
+        setState('ready');
+      } catch (cause) {
+        if (!active || !isCurrent(generation)) return;
+        setError(cause instanceof TargetRuntimeError ? cause : new TargetRuntimeError('service-unavailable', 'discovery', true, 'The selected environment could not be loaded. Try again.', target.id, cause));
+        setState('error');
+      }
+    })();
+    return () => {
+      active = false;
+    };
+  }, [auth.account, auth.acquireToken, auth.isAuthReady, generation, isCurrent, retry, target]);
+  if (auth.isLoading || !auth.isAuthReady) {
+    return /*#__PURE__*/_jsx(PowerAppsExperienceBoundary, {
+      experience: {
+        status: 'connecting',
+        environment: toEnvironmentSummary(target)
+      },
+      appDisplayName: target.appDisplayName,
+      component: experienceComponent,
+      fallback: /*#__PURE__*/_jsx(LoadingScreen, {
+        message: "Connecting to the selected environment..."
+      })
+    });
+  }
+  if (!auth.account) {
+    const fallback = /*#__PURE__*/_jsxs(View, {
+      style: {
+        flex: 1,
+        alignItems: 'center',
+        justifyContent: 'center',
+        gap: 16,
+        padding: 24
+      },
+      children: [/*#__PURE__*/_jsx(Text, {
+        children: auth.error?.message ?? 'Sign in to access the selected environment.'
+      }), /*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        onPress: () => {
+          void auth.signIn();
+        },
+        children: /*#__PURE__*/_jsx(Text, {
+          style: {
+            color: '#0F6CBD',
+            fontWeight: '600'
+          },
+          children: "Sign in"
+        })
+      }), /*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        onPress: onBack,
+        children: /*#__PURE__*/_jsx(Text, {
+          children: "Choose another environment"
+        })
+      })]
+    });
+    return /*#__PURE__*/_jsx(PowerAppsExperienceBoundary, {
+      experience: {
+        status: 'signIn',
+        error: auth.error?.message,
+        signIn: auth.signIn,
+        goBack: onBack
+      },
+      appDisplayName: target.appDisplayName,
+      component: experienceComponent,
+      fallback: fallback
+    });
+  }
+  if (state === 'error' && error) {
+    const retryResolution = () => setRetry(value => value + 1);
+    const fallback = /*#__PURE__*/_jsxs(View, {
+      style: {
+        flex: 1,
+        alignItems: 'center',
+        justifyContent: 'center',
+        gap: 16,
+        padding: 24
+      },
+      children: [/*#__PURE__*/_jsx(Text, {
+        style: {
+          fontWeight: '700'
+        },
+        children: "Unable to open environment"
+      }), /*#__PURE__*/_jsx(Text, {
+        children: error.userMessage
+      }), error.retryable ? /*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        onPress: retryResolution,
+        children: /*#__PURE__*/_jsx(Text, {
+          style: {
+            color: '#0F6CBD',
+            fontWeight: '600'
+          },
+          children: "Try again"
+        })
+      }) : null, /*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        onPress: onBack,
+        children: /*#__PURE__*/_jsx(Text, {
+          style: {
+            color: '#0F6CBD'
+          },
+          children: "Choose another environment"
+        })
+      })]
+    });
+    return /*#__PURE__*/_jsx(PowerAppsExperienceBoundary, {
+      experience: {
+        status: 'error',
+        error: toExperienceError(error),
+        retry: error.retryable ? retryResolution : undefined,
+        goBack: onBack
+      },
+      appDisplayName: target.appDisplayName,
+      component: experienceComponent,
+      fallback: fallback
+    });
+  }
+  if (!resolvedTarget) {
+    return /*#__PURE__*/_jsx(PowerAppsExperienceBoundary, {
+      experience: {
+        status: 'resolvingApp',
+        environment: toEnvironmentSummary(target)
+      },
+      appDisplayName: target.appDisplayName,
+      component: experienceComponent,
+      fallback: /*#__PURE__*/_jsx(LoadingScreen, {
+        message: "Loading app details..."
+      })
+    });
+  }
+  const broker = {
+    tenantId: target.tenantId,
+    generation,
+    acquireGlobalDiscoveryToken: async () => requireToken(await auth.acquireToken([globalDiscoveryScope(target.region)])),
+    acquireDataverseToken: async apiUrl => {
+      if (!areDataverseOriginAliases(apiUrl, resolvedTarget.dataverseApiUrl)) {
+        throw new Error('Dataverse token audience does not match the selected environment');
+      }
+      return requireToken(await auth.acquireToken([`${canonicalizeDataverseOrigin(apiUrl)}/.default`]));
+    },
+    acquirePowerPlatformToken: async region => {
+      if (region.toLowerCase() !== target.region.toLowerCase()) throw new Error('Power Platform region does not match the selected environment');
+      return requireToken(await auth.acquireToken([powerPlatformScope(target.region)]));
+    },
+    acquireConnectionUserConsentToken: async region => {
+      if (region.toLowerCase() !== target.region.toLowerCase()) throw new Error('Power Platform region does not match the selected environment');
+      return requireToken(await auth.acquireToken([connectionUserConsentScope(target.region)]));
+    },
+    acquireApiHubToken: async () => requireToken(await auth.acquireToken(['https://apihub.azure.com/.default']))
+  };
+  const runtime = children(resolvedTarget, {
+    clientId: msalConfig.clientId,
+    accountIdentifier: auth.account.identifier,
+    accountTenantId: auth.account.tenantId,
+    generation,
+    tokenBroker: broker,
+    signOut: auth.signOut
+  });
+  return /*#__PURE__*/_jsx(PowerAppsExperienceBoundary, {
+    experience: {
+      status: 'ready',
+      environment: toEnvironmentSummary(resolvedTarget)
+    },
+    appDisplayName: target.appDisplayName,
+    component: experienceComponent,
+    fallback: runtime,
+    children: runtime
+  });
+}
+function requireToken(token) {
+  if (!token) throw new Error('Authentication token is unavailable');
+  return token;
+}
+function EnvironmentSelector({
+  appDisplayName,
+  appName,
+  tenantPolicy,
+  onSelect,
+  experienceComponent
+}) {
+  const auth = useAuth();
+  const [environments, setEnvironments] = useState();
+  const [emptyResultReady, setEmptyResultReady] = useState(false);
+  const [error, setError] = useState();
+  const [retry, setRetry] = useState(0);
+  useEffect(() => {
+    if (!auth.account) return;
+    const accountIdentifier = auth.account.identifier;
+    let active = true;
+    let emptyResultTimer;
+    setEnvironments(undefined);
+    setEmptyResultReady(false);
+    setError(undefined);
+    if (!isTenantAllowed(auth.account.tenantId, tenantPolicy)) {
+      setError(new TargetRuntimeError('tenant-mismatch', 'authentication', false, 'Your organization is not approved to use this app.'));
+      return () => {
+        active = false;
+      };
+    }
+    void fetchAccessibleEnvironments(auth.account.tenantId, appDisplayName, appName, auth.acquireToken).then(async discovered => {
+      if (!active) return;
+      const storedId = await SecureStore.getItemAsync(TARGET_STORAGE_KEY).catch(() => null);
+      if (!active) return;
+      const restored = discovered.find(environment => environment.id === storedId);
+      if (restored) onSelect(restored, accountIdentifier);else {
+        if (storedId) void SecureStore.deleteItemAsync(TARGET_STORAGE_KEY);
+        setEnvironments(discovered);
+        if (discovered.length === 0) {
+          emptyResultTimer = setTimeout(() => {
+            if (active) setEmptyResultReady(true);
+          }, EMPTY_ENVIRONMENT_STABILITY_MS);
+        }
+      }
+    }).catch(cause => {
+      if (!active) return;
+      setError(cause instanceof TargetRuntimeError ? cause : new TargetRuntimeError('discovery-failed', 'discovery', true, 'Your environments could not be loaded. Try again.', undefined, cause));
+    });
+    return () => {
+      active = false;
+      if (emptyResultTimer) clearTimeout(emptyResultTimer);
+    };
+  }, [appDisplayName, appName, auth.account, auth.acquireToken, onSelect, retry, tenantPolicy]);
+  if (auth.isLoading || !auth.isAuthReady) {
+    return /*#__PURE__*/_jsx(PowerAppsExperienceBoundary, {
+      experience: {
+        status: 'preparing'
+      },
+      appDisplayName: appDisplayName,
+      component: experienceComponent,
+      fallback: /*#__PURE__*/_jsx(LoadingScreen, {
+        message: "Preparing your environments..."
+      })
+    });
+  }
+  if (!auth.account) {
+    const fallback = /*#__PURE__*/_jsxs(View, {
+      style: {
+        flex: 1,
+        alignItems: 'center',
+        justifyContent: 'center',
+        gap: 16,
+        padding: 24
+      },
+      children: [/*#__PURE__*/_jsx(Text, {
+        children: auth.error?.message ?? 'Sign in with your work or school account.'
+      }), /*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        onPress: () => {
+          void auth.signIn();
+        },
+        children: /*#__PURE__*/_jsx(Text, {
+          style: {
+            color: '#0F6CBD',
+            fontWeight: '600'
+          },
+          children: "Sign in"
+        })
+      })]
+    });
+    return /*#__PURE__*/_jsx(PowerAppsExperienceBoundary, {
+      experience: {
+        status: 'signIn',
+        error: auth.error?.message,
+        signIn: auth.signIn
+      },
+      appDisplayName: appDisplayName,
+      component: experienceComponent,
+      fallback: fallback
+    });
+  }
+  if (error) {
+    const retryDiscovery = () => setRetry(value => value + 1);
+    const fallback = /*#__PURE__*/_jsxs(View, {
+      style: {
+        flex: 1,
+        alignItems: 'center',
+        justifyContent: 'center',
+        gap: 16,
+        padding: 24
+      },
+      children: [/*#__PURE__*/_jsx(Text, {
+        style: {
+          fontWeight: '700'
+        },
+        children: "Unable to load environments"
+      }), /*#__PURE__*/_jsx(Text, {
+        children: error.userMessage
+      }), error.retryable ? /*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        onPress: retryDiscovery,
+        children: /*#__PURE__*/_jsx(Text, {
+          style: {
+            color: '#0F6CBD'
+          },
+          children: "Try again"
+        })
+      }) : null, /*#__PURE__*/_jsx(Pressable, {
+        accessibilityRole: "button",
+        onPress: () => {
+          void auth.signOut();
+        },
+        children: /*#__PURE__*/_jsx(Text, {
+          children: "Sign in with another account"
+        })
+      })]
+    });
+    return /*#__PURE__*/_jsx(PowerAppsExperienceBoundary, {
+      experience: {
+        status: 'error',
+        error: toExperienceError(error),
+        retry: error.retryable ? retryDiscovery : undefined,
+        signOut: auth.signOut
+      },
+      appDisplayName: appDisplayName,
+      component: experienceComponent,
+      fallback: fallback
+    });
+  }
+  if (!environments || environments.length === 0 && !emptyResultReady) {
+    return /*#__PURE__*/_jsx(PowerAppsExperienceBoundary, {
+      experience: {
+        status: 'discovering'
+      },
+      appDisplayName: appDisplayName,
+      component: experienceComponent,
+      fallback: /*#__PURE__*/_jsx(LoadingScreen, {
+        message: "Finding your environments..."
+      })
+    });
+  }
+  const fallback = /*#__PURE__*/_jsxs(View, {
+    style: {
+      flex: 1,
+      justifyContent: 'center',
+      gap: 12,
+      padding: 24
+    },
+    children: [/*#__PURE__*/_jsx(Text, {
+      style: {
+        fontSize: 20,
+        fontWeight: '700'
+      },
+      children: "Choose an environment"
+    }), environments.length === 0 ? /*#__PURE__*/_jsx(Text, {
+      children: "No accessible Dataverse environments were found."
+    }) : environments.map(target => /*#__PURE__*/_jsx(Pressable, {
+      accessibilityRole: "button",
+      onPress: () => onSelect(target, auth.account.identifier),
+      style: {
+        paddingVertical: 12
+      },
+      children: /*#__PURE__*/_jsx(Text, {
+        style: {
+          color: '#0F6CBD',
+          fontWeight: '600'
+        },
+        children: target.label
+      })
+    }, target.id)), /*#__PURE__*/_jsx(Pressable, {
+      accessibilityRole: "button",
+      onPress: () => {
+        void auth.signOut();
+      },
+      children: /*#__PURE__*/_jsx(Text, {
+        children: "Sign out"
+      })
+    })]
+  });
+  if (environments.length === 0) {
+    return /*#__PURE__*/_jsx(PowerAppsExperienceBoundary, {
+      experience: {
+        status: 'empty',
+        retry: () => setRetry(value => value + 1),
+        signOut: auth.signOut
+      },
+      appDisplayName: appDisplayName,
+      component: experienceComponent,
+      fallback: fallback
+    });
+  }
+  const selectEnvironment = environmentId => {
+    const target = environments.find(environment => environment.id === environmentId);
+    if (target) onSelect(target, auth.account.identifier);
+  };
+  return /*#__PURE__*/_jsx(PowerAppsExperienceBoundary, {
+    experience: {
+      status: 'selectEnvironment',
+      environments: environments.map(toEnvironmentSummary),
+      selectEnvironment,
+      signOut: auth.signOut
+    },
+    appDisplayName: appDisplayName,
+    component: experienceComponent,
+    fallback: fallback
+  });
+}
+export function PowerAppsTargetBootstrap({
+  msalConfig,
+  appDisplayName,
+  appName,
+  tenantPolicy,
+  experienceComponent,
+  children
+}) {
+  const ExperienceComponent = experienceComponent ?? DefaultPowerAppsExperience;
+  const [selected, setSelected] = useState();
+  const [bootstrapAccountIdentifier, setBootstrapAccountIdentifier] = useState();
+  const generationRef = useRef(0);
+  const [generation, setGeneration] = useState(0);
+  const isCurrentGeneration = useCallback(value => generationRef.current === value, []);
+  const select = useCallback((target, accountIdentifier) => {
+    generationRef.current += 1;
+    setGeneration(generationRef.current);
+    setSelected(target);
+    setBootstrapAccountIdentifier(accountIdentifier);
+    if (target) void SecureStore.setItemAsync(TARGET_STORAGE_KEY, target.id);else void SecureStore.deleteItemAsync(TARGET_STORAGE_KEY);
+  }, []);
+  if (!selected) {
+    return /*#__PURE__*/_jsx(AuthProvider, {
+      msalConfig: msalConfig,
+      authorityTenant: MULTI_TENANT_AUTHORITY,
+      requiredScopes: [globalDiscoveryScope('prod')],
+      children: /*#__PURE__*/_jsx(EnvironmentSelector, {
+        appDisplayName: appDisplayName,
+        appName: appName,
+        tenantPolicy: tenantPolicy,
+        onSelect: select,
+        experienceComponent: ExperienceComponent
+      })
+    }, `bootstrap:${generation}`);
+  }
+  return /*#__PURE__*/_jsx(AuthProvider, {
+    msalConfig: msalConfig,
+    authorityTenant: selected.tenantId,
+    expectedTenantId: selected.tenantId,
+    preferredAccountIdentifier: bootstrapAccountIdentifier,
+    autoAuthorizeMissingScopes: true,
+    requiredScopes: [`${selected.dataverseApiUrl}/user_impersonation`, powerPlatformScope(selected.region), 'https://apihub.azure.com/.default'],
+    children: /*#__PURE__*/_jsx(TargetRuntime, {
+      target: selected,
+      generation: generation,
+      msalConfig: msalConfig,
+      isCurrent: isCurrentGeneration,
+      onBack: () => select(undefined),
+      experienceComponent: ExperienceComponent,
+      children: children
+    })
+  }, `${selected.id}:${generation}`);
+}

package/lib/module/target/errors.js

@@ -0,0 +1,19 @@
+"use strict";
+
+export class TargetRuntimeError extends Error {
+  name = 'TargetRuntimeError';
+  constructor(code, stage, retryable, userMessage, targetId, cause) {
+    super(userMessage);
+    this.code = code;
+    this.stage = stage;
+    this.retryable = retryable;
+    this.userMessage = userMessage;
+    this.targetId = targetId;
+    Object.defineProperty(this, 'cause', {
+      value: cause,
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+  }
+}

package/lib/module/target/types.js

@@ -0,0 +1 @@
+"use strict";

package/lib/module/telemetry/index.js

@@ -12,7 +12,7 @@
 
 import { HttpClient } from '@microsoft/power-apps-native-common/http';
 import { isDebugLoggingEnabled } from "../logger.js";
-export { getAppLogger, configureAppLogger, getCustomerTelemetryLogger } from '@microsoft/power-apps-native-common';
+export { getAppLogger, configureAppLogger, getCustomEventsLogger } from '@microsoft/power-apps-native-common';
 /**
  * Canonical operation names for host package telemetry.
  * Follow the `PowerAppsHost.<Subsystem>.<Action>` convention so events are

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

@@ -14,7 +14,7 @@
  *   </AuthProvider>
  */
 import React from 'react';
-import type { MsalAuthConfig, IntuneConfig } from '@microsoft/power-apps-native-auth';
+import type { MSALAccount, MsalAuthConfig, IntuneConfig } from '@microsoft/power-apps-native-auth';
 export interface AuthState {
     isLoading: boolean;
     isAuthReady: boolean;
@@ -28,6 +28,7 @@ export interface AuthState {
      * in a perpetual "waiting-for-auth" retry loop.
      */
     hasRealAccount: boolean;
+    account: MSALAccount | null;
     error: Error | null;
     acquireToken: (scopes: string[]) => Promise<string | null>;
     signIn: () => Promise<void>;
@@ -48,9 +49,17 @@ export interface AuthProviderProps {
     intuneConfig?: IntuneConfig;
     /** Token audiences that must be available before the account is considered signed in. */
     requiredScopes?: string[];
+    /** Tenant that every cached and newly acquired account must belong to. */
+    expectedTenantId?: string;
+    /** Authority segment used to initialize MSAL, such as `organizations` or a tenant GUID. */
+    authorityTenant?: string;
+    /** Cached account to restore when moving between authority-specific providers. */
+    preferredAccountIdentifier?: string;
+    /** Automatically request missing consent for the preferred cached account. */
+    autoAuthorizeMissingScopes?: boolean;
     children: React.ReactNode;
 }
-export declare function AuthProvider({ msalConfig, intuneConfig, requiredScopes, children, }: AuthProviderProps): React.JSX.Element;
+export declare function AuthProvider({ msalConfig, intuneConfig, requiredScopes, expectedTenantId, authorityTenant, preferredAccountIdentifier, autoAuthorizeMissingScopes, children, }: AuthProviderProps): React.JSX.Element;
 /**
  * Returns the current auth state from the nearest <AuthProvider>.
  * Must be called within the AuthProvider tree.

package/lib/typescript/commonjs/auth/targetAuthorization.d.ts

@@ -0,0 +1,15 @@
+import type { MSALAccount, MSALResult } from '@microsoft/power-apps-native-auth';
+interface TargetAuthorizationClient {
+    acquireToken(params: {
+        scopes: string[];
+        loginHint?: string;
+    }): Promise<MSALResult>;
+    acquireTokenSilent(params: {
+        scopes: string[];
+        account: MSALAccount;
+    }): Promise<MSALResult>;
+}
+export declare function isInteractionRequired(error: unknown): boolean;
+export declare function authorizeRequiredScopes(client: TargetAuthorizationClient, account: MSALAccount, scopes: string[], expectedTenantId?: string): Promise<MSALAccount>;
+export {};
+//# sourceMappingURL=targetAuthorization.d.ts.map

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

@@ -53,6 +53,10 @@ export declare function buildConnectionReferences(powerConfigConnectionReference
     [key: string]: unknown;
 }>): Record<string, AppConnectionReference>;
 export type NativeBridgeOptions = {
+    /** Active target generation. Changes invalidate in-flight bridge requests. */
+    targetGeneration?: number;
+    /** Target and account identity represented by the current bridge options. */
+    runtimeIdentity?: string;
     /**
      * Return an auth token scoped to a connector API endpoint.
      * @param apiId - Connection API identifier (e.g. "shared_sharepointonline").
@@ -76,6 +80,7 @@ export type NativeBridgeOptions = {
 };
 export declare class NativePowerAppsBridge {
     private _options;
+    private _runtimeEpoch;
     constructor(_options: NativeBridgeOptions);
     /**
      * Updates the bridge's options in-place.
@@ -86,6 +91,7 @@ export declare class NativePowerAppsBridge {
      * via globalThis would have no effect — mutating options is the correct path.
      */
     updateOptions(options: NativeBridgeOptions): void;
+    invalidateRuntime(): void;
     initialize(): Promise<void>;
     /**
      * Hermes-safe body construction. Returns the raw body value so that

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

@@ -36,4 +36,6 @@ import type { NativeBridgeOptions } from './NativePowerAppsBridge';
  * ```
  */
 export declare function setupNativeHost(options: NativeBridgeOptions): void;
+/** Invalidates in-flight work without replacing the SDK-cached bridge singleton. */
+export declare function invalidateNativeHostRuntime(): void;
 //# sourceMappingURL=setupNativeHost.d.ts.map

package/lib/typescript/commonjs/config/runtimeTenantMode.d.ts

@@ -0,0 +1,3 @@
+import type { PowerAppsTenantMode } from './tenantMode';
+export declare function assertNativeTenantMode(tenantMode: PowerAppsTenantMode): void;
+//# sourceMappingURL=runtimeTenantMode.d.ts.map

package/lib/typescript/commonjs/config/runtimeTenantMode.web.d.ts

@@ -0,0 +1,3 @@
+import type { PowerAppsTenantMode } from './tenantMode';
+export declare function assertNativeTenantMode(_tenantMode: PowerAppsTenantMode): void;
+//# sourceMappingURL=runtimeTenantMode.web.d.ts.map

package/lib/typescript/commonjs/config/tenantMode.d.ts

@@ -0,0 +1,14 @@
+export type PowerAppsTenantMode = 'single' | 'multi';
+export type PowerAppsTenantPolicy = 'organizations' | {
+    allowedTenantIds: string[];
+};
+export declare const MULTI_TENANT_AUTHORITY = "common";
+export type PowerAppsMultiTenantConfig = {
+    appDisplayName: string;
+    appName: string;
+    tenantPolicy: PowerAppsTenantPolicy;
+};
+export declare function resolveTenantMode(appConfig: unknown): PowerAppsTenantMode;
+export declare function resolveMultiTenantConfig(appConfig: unknown): PowerAppsMultiTenantConfig;
+export declare function isTenantAllowed(tenantId: string, policy: PowerAppsTenantPolicy): boolean;
+//# sourceMappingURL=tenantMode.d.ts.map