@datalayer/core 1.2.10 → 1.2.12

package/lib/hooks/useCache.js

@@ -727,6 +727,10 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
          */
         if (raw.publicUrl)
             meta.publicUrl = raw.publicUrl;
+        if (raw.shareCardUrl)
+            meta.shareCardUrl = raw.shareCardUrl;
+        if (raw.shareCardVersion)
+            meta.shareCardVersion = raw.shareCardVersion;
         return meta;
     };
     /**
@@ -6853,6 +6857,104 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             onSuccess: invalidateArtifactVisibility,
         });
     };
+    /** Publish a public artifact natively to LinkedIn through Library's saga. */
+    const usePublishLinkedInShare = () => {
+        return useMutation({
+            mutationFn: async ({ itemId, commentary, idempotencyKey, imageDataUrl, imageAltText, }) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/shares/linkedin`,
+                    method: 'POST',
+                    headers: { 'Idempotency-Key': idempotencyKey },
+                    body: { commentary, imageDataUrl, imageAltText },
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to publish to LinkedIn');
+                }
+                return resp.share;
+            },
+        });
+    };
+    const useUnpublishLinkedInShare = () => {
+        return useMutation({
+            mutationFn: async (idempotencyKey) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/shares/linkedin/${encodeURIComponent(idempotencyKey)}`,
+                    method: 'DELETE',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to unpublish from LinkedIn');
+                }
+                return resp.share;
+            },
+        });
+    };
+    const useLinkedInShares = (itemId, enabled = true) => {
+        return useQuery({
+            queryKey: ['library', 'social-shares', 'linkedin', itemId],
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/shares/linkedin`,
+                    method: 'GET',
+                    notifyOnError: false,
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to load LinkedIn publications');
+                }
+                return Array.isArray(resp.shares) ? resp.shares : [];
+            },
+            ...DEFAULT_QUERY_OPTIONS,
+            enabled: Boolean(configuration.libraryUrl) && Boolean(itemId) && enabled,
+        });
+    };
+    /** Publish one selected public result through the durable Bluesky saga. */
+    const usePublishBlueskyShare = () => {
+        return useMutation({
+            mutationFn: async ({ itemId, finding, cellId, outputIndex, idempotencyKey, imageDataUrl, imageAltText, }) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/shares/bluesky`,
+                    method: 'POST',
+                    headers: { 'Idempotency-Key': idempotencyKey },
+                    body: { finding, cellId, outputIndex, imageDataUrl, imageAltText },
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to publish to Bluesky');
+                }
+                return resp.share;
+            },
+        });
+    };
+    const useUnpublishBlueskyShare = () => {
+        return useMutation({
+            mutationFn: async (idempotencyKey) => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/shares/bluesky/${encodeURIComponent(idempotencyKey)}`,
+                    method: 'DELETE',
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to unpublish from Bluesky');
+                }
+                return resp.share;
+            },
+        });
+    };
+    const useBlueskyShares = (itemId, enabled = true) => {
+        return useQuery({
+            queryKey: ['library', 'social-shares', 'bluesky', itemId],
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/shares/bluesky`,
+                    method: 'GET',
+                    notifyOnError: false,
+                });
+                if (!resp.success) {
+                    throw new Error(resp.message || 'Failed to load Bluesky publications');
+                }
+                return Array.isArray(resp.shares) ? resp.shares : [];
+            },
+            ...DEFAULT_QUERY_OPTIONS,
+            enabled: Boolean(configuration.libraryUrl) && Boolean(itemId) && enabled,
+        });
+    };
     /**
      * Tell the library that an artifact was reused: cloned into a space, or
      * instantiated as a runtime. The reuse itself belongs to the service that
@@ -6860,11 +6962,14 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
      */
     const useCountItemReuse = () => {
         return useMutation({
-            mutationFn: async ({ itemId, kind, }) => {
+            mutationFn: async ({ itemId, kind, signupSource, shareRef, }) => {
                 const resp = await requestDatalayer({
                     url: `${configuration.libraryUrl}/api/library/v1/items/${encodeURIComponent(itemId)}/reused`,
                     method: 'POST',
-                    body: { kind },
+                    body: {
+                        kind,
+                        ...(signupSource && shareRef ? { signupSource, shareRef } : {}),
+                    },
                 });
                 if (!resp.success) {
                     throw new Error(resp.message || 'Failed to count the reuse');
@@ -7062,215 +7167,80 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             },
         });
     };
-    /**
-     * Get LinkedIn profile via proxy
-     */
+    /** Get the server-connected LinkedIn profile. */
     const useGetLinkedinProfile = () => {
         return useMutation({
-            mutationFn: async (accessToken) => {
+            mutationFn: async () => {
                 return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                    method: 'POST',
-                    body: {
-                        request_method: 'GET',
-                        request_url: 'https://api.linkedin.com/v2/userinfo',
-                        request_token: accessToken,
-                    },
+                    url: `${configuration.iamUrl}/api/iam/v1/social/linkedin/profile`,
+                    method: 'GET',
                 });
             },
         });
     };
-    /**
-     * Post LinkedIn share
-     */
+    /** Publish a LinkedIn text post through the server-held connection. */
     const usePostLinkedinShare = () => {
         return useMutation({
-            mutationFn: async ({ linkedinUserUrn, postText, accessToken, }) => {
-                const postShareRequest = {
-                    author: linkedinUserUrn,
-                    lifecycleState: 'PUBLISHED',
-                    specificContent: {
-                        'com.linkedin.ugc.ShareContent': {
-                            shareCommentary: { text: postText },
-                            shareMediaCategory: 'NONE',
-                        },
-                    },
-                    visibility: {
-                        'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC',
-                    },
-                };
+            mutationFn: async ({ postText }) => {
                 return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
+                    url: `${configuration.iamUrl}/api/iam/v1/social/linkedin/posts`,
                     method: 'POST',
-                    body: {
-                        request_method: 'POST',
-                        request_url: 'https://api.linkedin.com/v2/ugcPosts',
-                        request_token: accessToken,
-                        request_body: postShareRequest,
-                    },
+                    body: { commentary: postText },
                 });
             },
         });
     };
-    /**
-     * Post LinkedIn share with image upload
-     */
+    /** Publish a LinkedIn post, optionally with one uploaded image. */
     const usePostLinkedinShareWithUpload = () => {
         return useMutation({
-            mutationFn: async ({ linkedinUserUrn, postText, uploadObject, accessToken, }) => {
-                let shareRequest;
-                if (uploadObject) {
-                    // Step 1: Register upload
-                    const registerUploadRequest = {
-                        registerUploadRequest: {
-                            recipes: ['urn:li:digitalmediaRecipe:feedshare-image'],
-                            owner: linkedinUserUrn,
-                            serviceRelationships: [
-                                {
-                                    relationshipType: 'OWNER',
-                                    identifier: 'urn:li:userGeneratedContent',
-                                },
-                            ],
-                        },
-                    };
-                    const registerResp = await requestDatalayer({
-                        url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                        method: 'POST',
-                        body: {
-                            request_method: 'POST',
-                            request_url: 'https://api.linkedin.com/v2/assets?action=registerUpload',
-                            request_token: accessToken,
-                            request_body: registerUploadRequest,
-                        },
-                    });
-                    const asset = registerResp.response.value.asset;
-                    const uploadUrl = registerResp.response.value.uploadMechanism['com.linkedin.digitalmedia.uploading.MediaUploadHttpRequest'].uploadUrl;
-                    // Step 2: Upload image
-                    await requestDatalayer({
-                        url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                        method: 'POST',
-                        body: {
-                            request_method: 'PUT',
-                            request_url: uploadUrl,
-                            request_token: accessToken,
-                            request_body: {
-                                uploadURL: uploadUrl,
-                                content: uploadObject,
-                                userURN: linkedinUserUrn,
-                            },
-                        },
-                    });
-                    // Step 3: Create share with media
-                    shareRequest = {
-                        author: linkedinUserUrn,
-                        lifecycleState: 'PUBLISHED',
-                        specificContent: {
-                            'com.linkedin.ugc.ShareContent': {
-                                shareCommentary: { text: postText },
-                                shareMediaCategory: 'IMAGE',
-                                media: [
-                                    {
-                                        status: 'READY',
-                                        description: { text: 'Datalayer Notebook' },
-                                        media: asset,
-                                        title: { text: 'Datalayer Notebook' },
-                                    },
-                                ],
-                            },
-                        },
-                        visibility: {
-                            'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC',
-                        },
-                    };
-                }
-                else {
-                    // Text-only share (no image upload)
-                    shareRequest = {
-                        author: linkedinUserUrn,
-                        lifecycleState: 'PUBLISHED',
-                        specificContent: {
-                            'com.linkedin.ugc.ShareContent': {
-                                shareCommentary: { text: postText },
-                                shareMediaCategory: 'NONE',
-                            },
-                        },
-                        visibility: {
-                            'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC',
-                        },
-                    };
-                }
+            mutationFn: async ({ postText, uploadObject, }) => {
                 return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
+                    url: `${configuration.iamUrl}/api/iam/v1/social/linkedin/posts`,
                     method: 'POST',
                     body: {
-                        request_method: 'POST',
-                        request_url: 'https://api.linkedin.com/v2/ugcPosts',
-                        request_token: accessToken,
-                        request_body: shareRequest,
-                    },
-                });
-            },
-        });
-    };
-    // ============================================================================
-    // Proxy Operations
-    // ============================================================================
-    /**
-     * Proxy GET request
-     */
-    const useProxyGET = () => {
-        return useMutation({
-            mutationFn: async ({ url, token }) => {
-                return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                    method: 'POST',
-                    body: {
-                        request_method: 'GET',
-                        request_url: url,
-                        request_token: token,
-                    },
-                });
-            },
-        });
-    };
-    /**
-     * Proxy POST request
-     */
-    const useProxyPOST = () => {
-        return useMutation({
-            mutationFn: async ({ url, body, token, }) => {
-                return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                    method: 'POST',
-                    body: {
-                        request_method: 'POST',
-                        request_url: url,
-                        request_token: token,
-                        request_body: body,
+                        commentary: postText,
+                        image_data_url: uploadObject,
                     },
                 });
             },
         });
     };
+    /** Connect-only AT Protocol account operations. */
+    const useGetBlueskyConnection = () => useMutation({
+        mutationFn: async () => requestDatalayer({
+            url: `${configuration.iamUrl}/api/iam/v1/social/bluesky/profile`,
+            method: 'GET',
+            notifyOnError: false,
+        }),
+    });
     /**
-     * Proxy PUT request
-     */
-    const useProxyPUT = () => {
-        return useMutation({
-            mutationFn: async ({ url, body, token, }) => {
-                return requestDatalayer({
-                    url: `${configuration.iamUrl}/api/iam/v1/proxy/request`,
-                    method: 'POST',
-                    body: {
-                        request_method: 'PUT',
-                        request_url: url,
-                        request_token: token,
-                        request_body: body,
-                    },
-                });
-            },
-        });
-    };
+     * Begin a Bluesky connection.
+     *
+     * `returnOrigin` is where the reader should come back to — their own origin,
+     * so a connection begun on a developer's machine does not end on
+     * production. IAM takes the origin only and builds the address itself, so
+     * this cannot ask to be sent anywhere.
+     */
+    const useConnectBluesky = () => useMutation({
+        mutationFn: async (asked) => {
+            const { identifier, returnOrigin } = typeof asked === 'string'
+                ? { identifier: asked, returnOrigin: undefined }
+                : asked;
+            return requestDatalayer({
+                url: `${configuration.iamUrl}/api/iam/v1/social/bluesky/connect`,
+                method: 'POST',
+                body: returnOrigin
+                    ? { identifier, return_origin: returnOrigin }
+                    : { identifier },
+            });
+        },
+    });
+    const useDisconnectBluesky = () => useMutation({
+        mutationFn: async () => requestDatalayer({
+            url: `${configuration.iamUrl}/api/iam/v1/social/bluesky/connection`,
+            method: 'DELETE',
+        }),
+    });
     // ============================================================================
     // Waiting List & Growth
     // ============================================================================
@@ -8319,11 +8289,16 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         useGetLinkedinProfile,
         usePostLinkedinShare,
         usePostLinkedinShareWithUpload,
+        useGetBlueskyConnection,
+        useConnectBluesky,
+        useDisconnectBluesky,
+        usePublishLinkedInShare,
+        useUnpublishLinkedInShare,
+        useLinkedInShares,
+        usePublishBlueskyShare,
+        useUnpublishBlueskyShare,
+        useBlueskyShares,
         useRegisterToWaitingList,
-        // Proxy
-        useProxyGET,
-        useProxyPOST,
-        useProxyPUT,
         // Users
         useUser,
         useUserByHandle,

package/lib/hooks/useMcp.js

@@ -34,7 +34,7 @@ import { deleteMcpPolicy, getAdmittedClients, getMcpPolicy, setMcpPolicy, } from
 import { createServiceAgent, listServiceAgents, revokeServiceAgent, rotateServiceAgentKey, } from '../api/iam/serviceAgents.js';
 import { useCoreStore, useIAMStore } from '../state/index.js';
 import { queryKeys } from './useCache.js';
-const useMcpServerUrl = () => useCoreStore(state => state.configuration.jupyterMcpServerUrl);
+const useMcpServerUrl = () => useCoreStore(state => state.configuration.datalayerMcpServerUrl);
 const useIamUrl = () => useCoreStore(state => state.configuration.iamUrl);
 const useOtelUrl = () => useCoreStore(state => state.configuration.otelUrl);
 // -- Tasks -----------------------------------------------------------------

package/lib/hooks/useNavigate.js

@@ -14,10 +14,17 @@
  * `window.open` otherwise, so a button gets it too. `newTab` in the options
  * opens a new tab outright.
  *
+ * Every navigation that stays in this tab is also **recorded** against the
+ * shell the reader is in ({@link state/substates/NavigationState}). That is
+ * what lets a reader switch from Agentify back to Home and find the page they
+ * left rather than a landing page, and it is done here — the one place every
+ * navigation goes through — rather than in an effect per layout.
+ *
  * @module hooks/useNavigate
  */
 import { useCallback, useMemo } from 'react';
 import { useLayoutStore } from '../state/index.js';
+import { navigationStore } from '../state/substates/NavigationState.js';
 import { createNativeNavigate } from '../navigation/adapters/native.js';
 // Import React Router hooks from our wrapper
 import { useNavigateRR } from '../navigation/adapters/react-router.js';
@@ -125,6 +132,9 @@ export const useNavigate = () => {
             window.scrollTo(0, 0);
             document.body.scrollTop = 0;
         }
+        // Where the reader is now, for the shell they are in. A new tab and a
+        // step back through history are both already past by here.
+        navigationStore.getState().rememberRoute(to);
         if (rrNavigate) {
             rrNavigate(to, { replace: options.replace, state: options.state });
             return;

package/lib/hooks/useWindowSize.js

@@ -50,7 +50,7 @@ export function useWindowSize() {
     return windowSize;
 }
 const breakpointSwitch = (value) => {
-    let current = BreakpointSize.XXLARGE;
+    let current;
     switch (true) {
         case value >= 320 && value < 544:
             current = BreakpointSize.XSMALL;

package/lib/models/IAMProvidersSpecs.d.ts

@@ -1,9 +1,15 @@
 import { IUser } from './User';
 export type IIAMProviderName = 'bluesky' | 'discord' | 'github' | 'google' | 'linkedin' | 'okta' | 'x';
+/** Providers whose access token is intentionally available to browser code. */
+export type IBrowserTokenProviderName = Exclude<IIAMProviderName, 'bluesky' | 'linkedin'>;
 export type IIAMProviderSpec = {
     name: IIAMProviderName;
     oauth2CallbackServerRoute: string;
     oauth2CallbackUIRoute: string;
+};
+/** Provider metadata used only when its access token may be read by the UI. */
+export type IBrowserTokenProviderSpec = IIAMProviderSpec & {
+    name: IBrowserTokenProviderName;
     accessTokenCookieName: (user: IUser) => string;
     refreshTokenCookieName: string;
     userInfoURL: string;
@@ -13,11 +19,10 @@ export type IIAMProviderSpec = {
 };
 export declare class IAMProvidersSpecs {
     private constructor();
-    static getProvider(providerIAMProvidersType: any): IIAMProviderSpec;
-    static readonly Bluesky: IIAMProviderSpec;
-    static readonly GitHub: IIAMProviderSpec;
-    static readonly Google: IIAMProviderSpec;
+    static getProvider(providerIAMProvidersType: IBrowserTokenProviderName): IBrowserTokenProviderSpec;
+    static readonly GitHub: IBrowserTokenProviderSpec;
+    static readonly Google: IBrowserTokenProviderSpec;
     static readonly LinkedIn: IIAMProviderSpec;
-    static readonly Okta: IIAMProviderSpec;
+    static readonly Okta: IBrowserTokenProviderSpec;
 }
 export default IAMProvidersSpecs;

package/lib/models/IAMProvidersSpecs.js

@@ -6,18 +6,12 @@ export class IAMProvidersSpecs {
     constructor() { }
     static getProvider(providerIAMProvidersType) {
         switch (providerIAMProvidersType) {
-            case 'bluesky': {
-                return this.Bluesky;
-            }
             case 'github': {
                 return this.GitHub;
             }
             case 'google': {
                 return this.Google;
             }
-            case 'linkedin': {
-                return this.LinkedIn;
-            }
             case 'okta': {
                 return this.Okta;
             }
@@ -27,17 +21,6 @@ export class IAMProvidersSpecs {
             }
         }
     }
-    static Bluesky = {
-        name: 'bluesky',
-        oauth2CallbackServerRoute: 'jupyter_iam/oauth2/callback',
-        oauth2CallbackUIRoute: '/iam/oauth2/bluesky/callback',
-        accessTokenCookieName: (user) => `__datalayer__bluesky_access_token_${user.id}`,
-        refreshTokenCookieName: '__datalayer__bluesky_refresh_token',
-        userInfoURL: '',
-        tokenRefreshURL: '',
-        postShareURL: '',
-        registerUploadURL: '',
-    };
     static GitHub = {
         name: 'github',
         oauth2CallbackServerRoute: 'jupyter_iam/oauth2/callback',
@@ -64,12 +47,6 @@ export class IAMProvidersSpecs {
         name: 'linkedin',
         oauth2CallbackServerRoute: 'jupyter_iam/oauth2/callback',
         oauth2CallbackUIRoute: '/iam/oauth2/linkedin/callback',
-        accessTokenCookieName: (user) => `__datalayer__linkedin_access_token_${user.id}`,
-        refreshTokenCookieName: '__datalayer__linkedin_refresh_token',
-        userInfoURL: 'https://api.linkedin.com/v2/userinfo',
-        tokenRefreshURL: '',
-        postShareURL: 'https://api.linkedin.com/v2/ugcPosts',
-        registerUploadURL: 'https://api.linkedin.com/v2/assets?action=registerUpload',
     };
     static Okta = {
         name: 'okta',

package/lib/navigation/adapters/react-router.d.ts

@@ -1,4 +1,4 @@
 import * as ReactRouterDom from 'react-router-dom';
 export declare const useParamsRR: typeof ReactRouterDom.useParams;
 export declare const useLocationRR: typeof ReactRouterDom.useLocation;
-export declare const useNavigateRR: typeof ReactRouterDom.useNavigate;
+export declare const useNavigateRR: () => ReactRouterDom.NavigateFunction;

package/lib/navigation/adapters/react-router.js

@@ -9,4 +9,7 @@ import * as ReactRouterDom from 'react-router-dom';
 // Export hooks for use in our navigation hooks
 export const useParamsRR = ReactRouterDom.useParams;
 export const useLocationRR = ReactRouterDom.useLocation;
+// Typed here rather than inferred: the inferred type carries React Router's
+// own doc comment, whose links (`redirect`, `To`, `<ScrollRestoration>`) point
+// at symbols these docs do not include, and typedoc fails the build on them.
 export const useNavigateRR = ReactRouterDom.useNavigate;

package/lib/state/sessionEnd.js

@@ -142,7 +142,7 @@ export const claimSessionState = (userUid) => {
         return;
     }
     const localStorage = storageOf('localStorage');
-    let owner = null;
+    let owner;
     try {
         owner = localStorage?.getItem(SESSION_OWNER_KEY) ?? null;
     }

package/lib/state/substates/CoreState.js

@@ -4,6 +4,7 @@
  */
 import { createStore } from 'zustand/vanilla';
 import { useStore } from 'zustand';
+import { DEFAULT_PLANE_URLS } from '../../config/planes.js';
 import { configLogger } from '../../utils/Logger.js';
 let loadConfigurationFromServer = true;
 let initialConfiguration = {
@@ -15,22 +16,8 @@ let initialConfiguration = {
     whiteLabel: true,
     loadConfigurationFromServer: true,
     jupyterServerless: false,
-    iamUrl: 'https://prod1.datalayer.run',
-    contentsUrl: 'https://r1.datalayer.run',
-    managerUrl: 'https://prod1.datalayer.run',
-    runtimesUrl: 'https://r1.datalayer.run',
-    schedulerUrl: 'https://r1.datalayer.run',
-    libraryUrl: 'https://prod1.datalayer.run',
-    spacerUrl: 'https://prod1.datalayer.run',
-    aiAgentsUrl: 'https://r1.datalayer.run',
-    aiInferenceUrl: 'https://r1.datalayer.run',
-    jupyterMcpServerUrl: 'https://mcp.datalayer.run/mcp',
-    otelUrl: 'https://prod1.datalayer.run',
-    // Defaults to prod so telemetry is consumed from the production OTEL service
-    growthUrl: 'https://prod1.datalayer.run',
-    inboundsUrl: 'https://prod1.datalayer.run',
-    successUrl: 'https://prod1.datalayer.run',
-    supportUrl: 'https://prod1.datalayer.run',
+    // Which plane each service is on is said once, in `config/planes`.
+    ...DEFAULT_PLANE_URLS,
     launcher: {
         category: 'Datalayer',
         name: 'Datalayer',

package/lib/state/substates/IAMState.d.ts

@@ -1,4 +1,4 @@
-import { IUser, IIAMProviderName } from '../../models';
+import { IUser, IIAMProviderName, IBrowserTokenProviderName } from '../../models';
 import type { ICredits, ICreditsReservation } from '../../models';
 /**
  * Limit to warn about low credits in milliseconds.
@@ -55,8 +55,8 @@ export type IAMState = IIAMState & {
      */
     refreshCredits: () => Promise<void>;
     checkIAMToken: (token: string) => Promise<void>;
-    setIAMProviderAccessToken: (provider: IIAMProviderName, accessToken?: string | null) => void;
-    getIAMProviderAccessToken: (user: IUser, provider: IIAMProviderName) => string | undefined;
+    setIAMProviderAccessToken: (provider: IBrowserTokenProviderName, accessToken?: string | null) => void;
+    getIAMProviderAccessToken: (user: IUser, provider: IBrowserTokenProviderName) => string | undefined;
     refreshUser: () => Promise<void>;
     refreshUserByTokenStored: () => Promise<void>;
     refreshUserByToken: (token: string) => Promise<void>;