@orangelogic/orange-dam-content-browser-sdk 2.2.8 → 2.3.0

package/build/{src/store → store}/auth/auth.service.d.ts

@@ -1,4 +1,4 @@
-import { GetAccessKeyRes, GetAccessTokenRes, RequestAuthorizeRes } from '@/types/auth';
+import { GetAccessKeyRes, GetAccessTokenRes, RequestAuthorizeRes } from '../../types/auth';
 export declare const AUTH_MAX_RETRIES = 10;
 export declare const CANCEL_AUTH_MESSAGE = "Authentication cancelled";
 export declare const authAbortController: {

package/build/store/auth/auth.slice.d.ts

@@ -0,0 +1,148 @@
+import type { PayloadAction } from '@reduxjs/toolkit';
+import { AUTH_FEATURE_ACCESS_KEY_KEY, AUTH_FEATURE_KEY, AUTH_FEATURE_SITE_URL_KEY, USE_SESSION } from '../../consts/auth';
+import { RootState } from '../../store';
+import { OAuthRes } from '../../types/auth';
+export { AUTH_FEATURE_ACCESS_KEY_KEY, AUTH_FEATURE_KEY, AUTH_FEATURE_SITE_URL_KEY, USE_SESSION };
+export type AuthState = {
+    siteUrl: string;
+    userConfigSiteUrl?: string;
+    nonce?: string;
+    accessToken?: string;
+    accessKey?: string;
+    oAuthUrl?: string;
+    error?: string;
+    status: 'authenticated' | 'unauthenticated' | 'restoreSession' | 'requestLogin' | 'waitForAuthorize';
+    useHeaders?: boolean;
+    useSession: string;
+};
+export declare const authSlice: import("@reduxjs/toolkit").Slice<AuthState, {
+    setAccessToken: (state: {
+        siteUrl: string;
+        userConfigSiteUrl?: string | undefined;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        accessKey?: string | undefined;
+        oAuthUrl?: string | undefined;
+        error?: string | undefined;
+        status: "authenticated" | "unauthenticated" | "restoreSession" | "requestLogin" | "waitForAuthorize";
+        useHeaders?: boolean | undefined;
+        useSession: string;
+    }, action: PayloadAction<string | undefined>) => void;
+    updateAuthTokens: (state: {
+        siteUrl: string;
+        userConfigSiteUrl?: string | undefined;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        accessKey?: string | undefined;
+        oAuthUrl?: string | undefined;
+        error?: string | undefined;
+        status: "authenticated" | "unauthenticated" | "restoreSession" | "requestLogin" | "waitForAuthorize";
+        useHeaders?: boolean | undefined;
+        useSession: string;
+    }, action: PayloadAction<Partial<AuthState>>) => void;
+    setSiteUrl: (state: {
+        siteUrl: string;
+        userConfigSiteUrl?: string | undefined;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        accessKey?: string | undefined;
+        oAuthUrl?: string | undefined;
+        error?: string | undefined;
+        status: "authenticated" | "unauthenticated" | "restoreSession" | "requestLogin" | "waitForAuthorize";
+        useHeaders?: boolean | undefined;
+        useSession: string;
+    }, action: PayloadAction<string>) => void;
+    setUserConfigSiteUrl: (state: {
+        siteUrl: string;
+        userConfigSiteUrl?: string | undefined;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        accessKey?: string | undefined;
+        oAuthUrl?: string | undefined;
+        error?: string | undefined;
+        status: "authenticated" | "unauthenticated" | "restoreSession" | "requestLogin" | "waitForAuthorize";
+        useHeaders?: boolean | undefined;
+        useSession: string;
+    }, action: PayloadAction<string>) => void;
+    generateNonce: (state: {
+        siteUrl: string;
+        userConfigSiteUrl?: string | undefined;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        accessKey?: string | undefined;
+        oAuthUrl?: string | undefined;
+        error?: string | undefined;
+        status: "authenticated" | "unauthenticated" | "restoreSession" | "requestLogin" | "waitForAuthorize";
+        useHeaders?: boolean | undefined;
+        useSession: string;
+    }) => void;
+    logout: (state: {
+        siteUrl: string;
+        userConfigSiteUrl?: string | undefined;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        accessKey?: string | undefined;
+        oAuthUrl?: string | undefined;
+        error?: string | undefined;
+        status: "authenticated" | "unauthenticated" | "restoreSession" | "requestLogin" | "waitForAuthorize";
+        useHeaders?: boolean | undefined;
+        useSession: string;
+    }) => void;
+    setAuthStatus: (state: {
+        siteUrl: string;
+        userConfigSiteUrl?: string | undefined;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        accessKey?: string | undefined;
+        oAuthUrl?: string | undefined;
+        error?: string | undefined;
+        status: "authenticated" | "unauthenticated" | "restoreSession" | "requestLogin" | "waitForAuthorize";
+        useHeaders?: boolean | undefined;
+        useSession: string;
+    }, action: PayloadAction<AuthState["status"]>) => void;
+    setUseSession: (state: {
+        siteUrl: string;
+        userConfigSiteUrl?: string | undefined;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        accessKey?: string | undefined;
+        oAuthUrl?: string | undefined;
+        error?: string | undefined;
+        status: "authenticated" | "unauthenticated" | "restoreSession" | "requestLogin" | "waitForAuthorize";
+        useHeaders?: boolean | undefined;
+        useSession: string;
+    }, action: PayloadAction<string>) => void;
+    setUseHeaders: (state: {
+        siteUrl: string;
+        userConfigSiteUrl?: string | undefined;
+        nonce?: string | undefined;
+        accessToken?: string | undefined;
+        accessKey?: string | undefined;
+        oAuthUrl?: string | undefined;
+        error?: string | undefined;
+        status: "authenticated" | "unauthenticated" | "restoreSession" | "requestLogin" | "waitForAuthorize";
+        useHeaders?: boolean | undefined;
+        useSession: string;
+    }, action: PayloadAction<boolean>) => void;
+}, "auth", "auth", import("@reduxjs/toolkit").SliceSelectors<AuthState>>;
+declare const _default: import("redux").Reducer<AuthState>;
+export default _default;
+export declare const logout: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"auth/logout">, setAccessToken: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<string | undefined, "auth/setAccessToken">, generateNonce: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"auth/generateNonce">, setSiteUrl: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "auth/setSiteUrl">, setUserConfigSiteUrl: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "auth/setUserConfigSiteUrl">, setUseSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "auth/setUseSession">, setUseHeaders: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, "auth/setUseHeaders">, setAuthStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<"authenticated" | "unauthenticated" | "restoreSession" | "requestLogin" | "waitForAuthorize", "auth/setAuthStatus">;
+export declare const authenticatedSelector: (rootState: RootState) => boolean;
+export declare const accessKeySelector: (rootState: RootState) => string | undefined;
+export declare const accessTokenSelector: (rootState: RootState) => string | undefined;
+export declare const oAuthUrlSelector: (rootState: RootState) => string | undefined;
+export declare const siteUrlSelector: (rootState: RootState) => string;
+export declare const userConfigSiteUrlSelector: (rootState: RootState) => string | undefined;
+export declare const authErrorSelector: (rootState: RootState) => string | undefined;
+export declare const nonceSelector: (rootState: RootState) => string | undefined;
+export declare const authStateSelector: (rootState: RootState) => "authenticated" | "unauthenticated" | "restoreSession" | "requestLogin" | "waitForAuthorize";
+export declare const applySessionSelector: (rootState: RootState) => string;
+export declare const applyHeadersSelector: (rootState: RootState) => boolean;
+export declare const appAuthUrlSelector: (rootState: RootState) => string;
+export declare const cancelAuth: import("@reduxjs/toolkit").AsyncThunk<void, void, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const oAuth: import("@reduxjs/toolkit").AsyncThunk<OAuthRes, {
+    siteUrl: string;
+    callbackFn?: (url: string) => void;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const initAuthInfoFromCache: import("@reduxjs/toolkit").AsyncThunk<undefined, void, import("@reduxjs/toolkit").AsyncThunkConfig>;

package/build/store/index.d.ts

@@ -0,0 +1,14 @@
+import type { TypedUseSelectorHook } from 'react-redux';
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    auth: import("./auth/auth.slice").AuthState;
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        auth: import("./auth/auth.slice").AuthState;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;
+export declare const useAppDispatch: () => import("redux-thunk").ThunkDispatch<{
+    auth: import("./auth/auth.slice").AuthState;
+}, undefined, import("redux").UnknownAction> & import("redux").Dispatch<import("redux").UnknownAction>;
+export declare const useAppSelector: TypedUseSelectorHook<RootState>;

package/build/styles/component.styles.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("lit").CSSResult;
+export default _default;

package/build/tools/fetch-and-merge-assets.d.ts

@@ -0,0 +1,122 @@
+import CortexElement from '../base/element';
+import { GetAssetLinksRequest, GetAvailableExtensionsResponse } from '../api/asset/asset.types';
+import { Asset, GetAssetsRequest, MediaType } from '../types/asset';
+import { UserInfo } from '../types/auth';
+import { Facet, SortOrder } from '../types/content-browser';
+import { GetFolderRequest } from '../types/folder';
+import type { ReactiveController } from 'lit';
+type FetchAndMergeAssetsControllerOptions = {
+    availableDocTypes: string[];
+    baseUrl: string;
+    defaultFolderId: string;
+    defaultIsSeeThrough: boolean;
+    defaultSearchText: string;
+    defaultSelectedFacets: Record<string, string[]>;
+    defaultSortDirection: 'ascending' | 'descending';
+    defaultSortOrderName: string;
+    token: string;
+    useSession: string;
+};
+type FetchAndMergeAssetsControllerDataOptions = {
+    allowedExtensions: string[];
+    availableRepresentativeSubtypes: string[];
+};
+export declare class FetchAndMergeAssetsController implements ReactiveController {
+    #private;
+    private readonly host;
+    private availableFacets;
+    private facets;
+    private items;
+    private totalCount;
+    private lastRequest;
+    private sortOrders;
+    private parameters;
+    private availableExtensions;
+    private userInfo;
+    private loading;
+    private isLoggedIn;
+    private token;
+    private useSession;
+    private pendingTokenRefresh;
+    private resolvePendingTokenRefresh;
+    private readonly tokenRefreshTimeoutMs;
+    private readonly availableDocTypes;
+    private readonly defaultSearchText;
+    private readonly defaultSelectedFacets;
+    private readonly defaultSortOrderName;
+    private readonly defaultSortDirection;
+    private readonly defaultFolderId;
+    private readonly defaultIsSeeThrough;
+    private requestInterceptorId;
+    private responseInterceptorId;
+    constructor(host: CortexElement, { availableDocTypes, baseUrl, defaultFolderId, defaultIsSeeThrough, defaultSearchText, defaultSelectedFacets, defaultSortDirection, defaultSortOrderName, token, useSession, }: FetchAndMergeAssetsControllerOptions);
+    private waitForNewToken;
+    updateAuth(token: string, useSession: string): void;
+    private fetchInitialData;
+    private _debounceTimeout;
+    private _debouncePromise;
+    private _debounceResolve;
+    private mapAvailableExtensions;
+    fetchAssets(request: GetAssetsRequest): Promise<import("../api/asset/asset.types").GetAssetsResponse>;
+    fetchFolders(request: GetFolderRequest): Promise<import("../types/folder").GetFolderResponse>;
+    /**
+     * A folder switch (or any refetch) can return a facet list that no longer includes a
+     * currently-selected value. Keep those selected-but-missing values visible (count 0) instead
+     * of silently dropping them from the filter dropdown, mirroring the legacy React behavior.
+     */
+    private mergeFacetsWithSelected;
+    fetchAndMergeAssets(request: GetAssetsRequest): Promise<void>;
+    fetchAssetFavoriteStatus(id: string): Promise<boolean>;
+    fetchAssetByID(id: string, options?: {
+        allowedExtensions?: string[];
+        canFavorite?: boolean;
+    }): Promise<{
+        asset: {
+            allowATSLink: boolean;
+            docSubType: string;
+            docType: MediaType;
+            extension: string;
+            height: string;
+            id: string;
+            identifier: string;
+            imageUrl: string;
+            inColdStorage: boolean;
+            name: string;
+            originalUrl: string;
+            previewUrl: string;
+            recordId: string;
+            scrubUrl: string;
+            size: string;
+            tags: string;
+            width: string;
+        };
+        isFavorite: boolean;
+        proxies: import("../types/asset").AvailableProxy[];
+    } | undefined>;
+    fetchAssetVersionHistory(id: string): Promise<import("../api/asset/asset.types").GetAssetVersionHistoryResponse>;
+    addAssetToFavorite(id: string): Promise<boolean>;
+    removeAssetFromFavorite(id: string): Promise<boolean>;
+    getAssetLink(payload: GetAssetLinksRequest): Promise<import("../api/asset/asset.types").GetAssetLinksResponse>;
+    getData(options?: FetchAndMergeAssetsControllerDataOptions): {
+        availableExtensions: GetAvailableExtensionsResponse | null;
+        availableFacets: Array<Facet["facetDetails"]>;
+        facets: Facet[];
+        isLoggedIn: boolean;
+        items: Array<Asset & Record<string, string | boolean>>;
+        loading: boolean;
+        parameters: {
+            ATSEnabled?: boolean;
+            autoExtension?: string;
+            collectionPath?: string;
+            supportedExtensions?: string[];
+            supportedRepresentativeSubtypes?: string[];
+        } | null;
+        request: GetAssetsRequest | null;
+        sortOrders: Record<string, SortOrder[]>;
+        totalCount: number;
+        userInfo: UserInfo | null;
+    };
+    hostConnected(): void;
+    hostDisconnected(): void;
+}
+export {};

package/build/types/asset.d.ts

@@ -0,0 +1,94 @@
+export type AssetVersion = {
+    createByEmail: string;
+    fileImportDate: string;
+    scrubUrl: string;
+    versionCreateDate: string;
+    versionFileName: string;
+    versionFileUrl: string;
+    versionId: string;
+    versionNumber: number;
+    versionNumberDisplay: string;
+};
+export type AvailableProxy = {
+    cdnName: string | null;
+    extension: string | null;
+    formatHeight: number;
+    formatWidth: number;
+    height: number;
+    id: string;
+    permanentLink: string | null;
+    proxyLabel: string;
+    proxyName: string;
+    width: number;
+};
+export type TrackingParameter = {
+    key: string;
+    value: string;
+};
+export declare enum MediaType {
+    Album = "Album",
+    Audio = "Audio",
+    Image = "Image",
+    Multimedia = "Multimedia",
+    Story = "Story",
+    Video = "Video",
+    Widget = "Widget"
+}
+export type Asset = {
+    allowATSLink?: boolean;
+    docSubType: string;
+    docType: MediaType;
+    extension: string;
+    height?: string;
+    id: string;
+    identifier: string;
+    imageUrl: string;
+    inColdStorage?: boolean;
+    name: string;
+    originalUrl: string;
+    recordId: string;
+    scrubUrl?: string;
+    size: string;
+    tags: string;
+    width?: string;
+};
+export type AssetLinkInfo = {
+    cdnName: string | null;
+    extension: string | null;
+    height: number | null;
+    isCustomFormat: boolean | null;
+    permanentLink: string | null;
+    proxyLabel: string | null;
+    proxyName: string | null;
+    width: number | null;
+};
+export type AssetTransformationInfo = {
+    extension: string | null;
+    height: number | null;
+    isCustomFormat: boolean;
+    permanentLink: string | null;
+    width: number | null;
+};
+export type GetAssetLinksRequest = {
+    asset: Asset;
+    extension: string;
+    extraFields?: string[];
+    parameters?: TrackingParameter[];
+    permanentLink?: string;
+    proxyPreference?: string;
+    selectedProxyMetadata?: AssetLinkInfo;
+    useRepresentative?: boolean;
+};
+export type GetAssetsRequest = {
+    folderId?: string;
+    isSeeThrough?: boolean;
+    limitedToDocTypes?: string[];
+    pageSize?: number;
+    searchText?: string;
+    selectedFacets?: Record<string, string[]>;
+    sortDirection?: string;
+    sortOrder?: string;
+    sortOrderName?: string;
+    start?: number;
+    useSession?: string;
+};

package/build/{src/types → types}/auth.d.ts

@@ -1,20 +1,8 @@
-export type AuthorizationResult = {
-    requestID: string;
-};
 export declare enum GetAccessKeyResponseCode {
     Authorized = "Authorized",
     RepeatRequest = "RepeatRequest",
     NotAuthorized = "NotAuthorized"
 }
-export type GetAccessKeyResponse = {
-    accessKey?: string;
-    code: GetAccessKeyResponseCode;
-    message?: string;
-};
-export type GetAccessTokenResponse = {
-    accessToken?: string;
-    success: boolean;
-};
 export type RequestAuthorizeRes = {
     nonce: string;
     requestID: string;
@@ -33,3 +21,10 @@ export type OAuthRes = {
     accessToken?: string;
     siteUrl: string;
 };
+export type UserInfo = {
+    avatar?: string;
+    email?: string;
+    favoriteFolderRecordID?: string;
+    fullName?: string;
+    loginID?: string;
+};

package/build/types/base.d.ts

@@ -0,0 +1,4 @@
+export declare enum Orientation {
+    Horizontal = "horizontal",
+    Vertical = "vertical"
+}

package/build/types/content-browser.d.ts

@@ -0,0 +1,120 @@
+export declare enum OptionType {
+    FILTER = "filter",
+    SORT_DIRECTION = "sort-direction",
+    SORT_ORDER = "sort-order"
+}
+export type ControlOption = {
+    label: string;
+    value: string;
+};
+export type ChangeOption = {
+    type: OptionType;
+    value: string;
+};
+export type Facet = {
+    facetDetails: {
+        displayName: string;
+        facetFieldName: string;
+        facetIndexedFieldName?: string;
+    };
+    values: Array<{
+        count: number;
+        displayValue: string;
+        value: string;
+    }>;
+};
+export type SortOrder = {
+    description: string;
+    id: string;
+    isDefault?: boolean;
+    legacyValue: string;
+    name: string;
+    sortDirection: string;
+    sortDirectionDisplayName: string;
+    sortDirectionGroupKey: string;
+    sortType: string;
+};
+export declare enum GridView {
+    Large = "large",
+    Medium = "medium",
+    Small = "small"
+}
+export declare const ASSET_SIZE: {
+    small: {
+        maxWidth: number;
+        minWidth: number;
+    };
+    medium: {
+        maxWidth: number;
+        minWidth: number;
+    };
+    large: {
+        maxWidth: number;
+        minWidth: number;
+    };
+};
+export declare enum Unit {
+    AspectRatio = "%",
+    Pixel = "px"
+}
+export declare const cropModes: {
+    label: string;
+    value: string;
+}[];
+export declare const INPUT_DEBOUNCE_DELAY = 1000;
+export type Proxy = {
+    cdnName: string | null;
+    extension: string | null;
+    formatHeight: number;
+    formatWidth: number;
+    height: number;
+    id: string;
+    permanentLink: string | null;
+    proxyLabel: string;
+    proxyName: string;
+    width: number;
+};
+export declare enum TransformationAction {
+    Crop = "Crop",
+    Metadata = "Metadata",
+    Proxy = "Proxy",
+    Quality = "Quality",
+    Resize = "Resize",
+    Rotate = "Rotate"
+}
+export type Transformation = {
+    key: TransformationAction;
+    value: {
+        disabledSize?: boolean;
+        height?: number;
+        keepMetadata?: boolean;
+        mode?: string;
+        quality?: number;
+        rotation?: number;
+        unit?: Unit;
+        width?: number;
+        x?: number;
+        y?: number;
+    };
+};
+export type Parameter = {
+    key: string;
+    value: string;
+};
+export type CropMode = {
+    auto?: boolean;
+    disabledSize?: boolean;
+    label: string;
+    value: string;
+};
+export type FocusMode = {
+    auto?: boolean;
+    label: string;
+    value: string;
+};
+export type DefaultFocusMode = 'manual' | 'center';
+export type CtaTextTransform = 'none' | 'uppercase' | 'lowercase' | 'capitalize';
+export declare enum ContentBrowserFormatDialogVariant {
+    Dialog = "dialog",
+    Drawer = "drawer"
+}

package/build/types/folder.d.ts

@@ -0,0 +1,35 @@
+export declare enum FolderSelectVariant {
+    Input = "input",
+    Select = "select"
+}
+export type Folder = {
+    docType: string;
+    fullPath: string;
+    hasChildren: boolean;
+    id: string;
+    isShared?: boolean;
+    representativeAssetId?: string;
+    title: string;
+    url?: string;
+};
+export type GetFolderResponse = {
+    data: Folder[];
+    hasMore: boolean;
+    totalCount: number;
+};
+export type GetFolderRequest = {
+    allowedFolders?: string[];
+    baseUrl?: string;
+    bearerToken?: string;
+    excludeVirtualFolders?: boolean;
+    folderId: string;
+    includeDirectChild?: boolean;
+    limit?: number;
+    searchTerm?: string;
+    seeThru?: boolean;
+    self?: boolean;
+    start?: number;
+    token?: string;
+    useSession?: string;
+};
+export type FolderSelectApi = (params: GetFolderRequest) => Promise<GetFolderResponse>;

package/build/{src/types → types}/search.d.ts

@@ -88,20 +88,6 @@ export type GetAssetLinkResponse = {
     assetLinkInfo?: AssetLinkInfo | AssetTransformationInfo;
     assetTransformationSource?: AssetLinkInfo;
 };
-export type GetTransformedAssetLinkResponse = {
-    expirationDate: string | null;
-    fileExtension: string | null;
-    format: string;
-    identifier: string;
-    imageResizingMethod: string | null;
-    link: string;
-    maxHeight: number;
-    maxWidth: number;
-    recordID: string;
-};
-export type GetFavoritesResponse = {
-    favoriteRecordIds: string[] | null;
-};
 export type GetFoldersRequest = {
     allowedFolders?: string[];
     folder?: Folder;
@@ -111,7 +97,7 @@ export type GetFoldersRequest = {
     pageSize?: number;
     self?: boolean;
     includeDirectChild?: boolean;
-    damViewSeeThru?: boolean;
+    contentBrowserSeeThru?: boolean;
 };
 export declare enum MediaType {
     Album = "Album",
@@ -127,26 +113,3 @@ export declare enum GridView {
     Medium = "medium",
     Large = "large"
 }
-export declare enum SortDirection {
-    Ascending = "ascending",
-    Descending = "descending"
-}
-export type Filter = {
-    mediaTypes: string[];
-    visibilityClasses: string[];
-    statuses: string[];
-    extensions: string[];
-};
-export type Proxy = {
-    cdnName: string | null;
-    extension: string | null;
-    id: string;
-    formatHeight: number;
-    formatWidth: number;
-    height: number;
-    permanentLink: string | null;
-    proxyLabel: string;
-    proxyName: string;
-    width: number;
-    canAssumeFormatExists: boolean;
-};

package/build/{src/utils → utils}/api.d.ts

@@ -1,4 +1,3 @@
-import { BaseQueryFn, FetchArgs, FetchBaseQueryError } from '@reduxjs/toolkit/dist/query';
 type CortexFetchOptions = RequestInit & {
     /**
      * Time out in milliseconds
@@ -8,14 +7,14 @@ type CortexFetchOptions = RequestInit & {
      * Extended with timeout option and retry option. This value is true by default.
      * Fetch the data from the given url with retry when the response is not ok or have status code 401
      * This function will try to fetch the data again with a new token if the previous token is expired
-     * The token will be refreshed similar to the logic in AppBaseQuery
      */
     retryWhenUnauthorize?: boolean;
 };
-export declare const AppBaseQuery: BaseQueryFn<string | FetchArgs, unknown, FetchBaseQueryError>;
-export declare function GetValueByKeyCaseInsensitive(obj: {
-    [key: string]: string;
-}, key: string): string | undefined;
+/**
+ * Refresh the access token using the stored access key. De-duplicates concurrent calls via a shared mutex.
+ * Returns the new access token on success, or null if refresh failed (in which case the user is also logged out).
+ */
+export declare const refreshAccessToken: () => Promise<string | null>;
 export declare const checkCorrectSiteUrl: (url: string) => Promise<string | null>;
 /**
  * Wrapper of fetch API with timeout option