@bynder/compact-view 5.0.2 → 5.0.3

package/App.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { AssetFilterJson } from './filter/assetFilter.type';
+import { AssetType } from './views/asset/asset.type';
+import { SelectionMode } from './app-config/appConfig.type';
+import { Theme } from './style/Theming';
+import { File } from './select/file.type';
+export interface Props {
+    assetFieldSelection?: string;
+    assetFilter?: AssetFilterJson;
+    assetTypes?: AssetType[];
+    defaultSearchTerm?: string;
+    language?: string;
+    mode?: SelectionMode;
+    onSuccess?: (assets: unknown[], additionalInformation: {
+        selectedFile?: File;
+    }) => void;
+    theme?: Theme;
+    hideExternalAccess?: boolean;
+    selectedAssets?: string[];
+    hideLimitedUse?: boolean;
+    isContainerMode?: boolean;
+    __shouldAddOriginal__?: boolean;
+    hideSwitch?: boolean;
+    noCache?: boolean;
+    selectAllOption?: boolean;
+}
+export declare function App({ assetFieldSelection, assetFilter, assetTypes, defaultSearchTerm, language, mode, onSuccess, theme, hideExternalAccess, selectedAssets, hideLimitedUse, isContainerMode, __shouldAddOriginal__, hideSwitch, noCache, selectAllOption, }: Props): React.JSX.Element;

package/Components.d.ts

@@ -0,0 +1,20 @@
+export { AssetCard as Asset } from './views/asset/asset-card/AssetCard';
+export { type Asset as displayAsset } from './views/asset/asset.type';
+export { AssetList } from './views/asset/AssetList';
+export { Button } from '@bynder/design-system';
+export { Card } from '@bynder/design-system';
+export { Checkbox } from '@bynder/design-system';
+export { Chip } from './common/components/Chip';
+export { Dropdown } from './common/components/dropdown/Dropdown';
+export { DropdownListItem } from './common/components/dropdown/DropdownListItem';
+export { MetaPropertyFilterContent as Metaproperty, type MetapropertyType as metaproperty, } from './filter/filters/metaproperty/MetapropertyFilterContent';
+export { MetapropertyOptionComponent as MetapropertyOption, type MetapropertyOptionType as metapropertyOption, } from './filter/filters/metaproperty/MetapropertyOption';
+export { SmartFilterContent as Smartfilter, type SmartfilterType as smartfilter, } from './filter/filters/metaproperty/SmartFilterContent';
+export { HorizontalScroll } from './common/components/HorizontalScroll';
+export { InfiniteScroll } from './common/components/InfiniteScroll';
+export { Modal } from './common/components/Modal';
+export { NoResults } from './common/components/NoResults';
+export { Oops } from './error-handling/Oops';
+export { ShadowRoot } from './style/shadowroot/ShadowRoot';
+export { Skeleton } from './common/components/Skeleton';
+export { Spinner } from './common/components/Spinner';

package/Dat/Dat.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Transformation } from './types';
+interface Props {
+    transformBaseUrl: string;
+    assetName: string;
+    extension: string;
+    transformation?: Transformation;
+    setTransformation: (transformation?: Transformation) => void;
+    closeDat: () => void;
+}
+export declare function Dat({ transformBaseUrl, assetName, extension, transformation, setTransformation, closeDat, }: Props): React.ReactPortal | null;
+export {};

package/Dat/DatContext.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Asset } from '../views/asset/asset.type';
+import { Transformation } from './types';
+export declare function DatProvider(props: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useTransformations(): {
+    transformation?: Transformation | undefined;
+    setTransformation: (transformation?: Transformation | undefined) => void;
+    openDat: (url: string, asset: Asset, name: string) => void;
+    closeDat: () => void;
+};

package/Dat/DatDropdownItem.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { Asset } from '../views/asset/asset.type';
+interface Props {
+    transformBaseUrl?: string;
+    asset: Asset;
+    toggleDropdown: () => void;
+}
+export declare function DatDropdownItem({ transformBaseUrl, asset, toggleDropdown }: Props): React.JSX.Element | null;
+export {};

package/Dat/index.d.ts

@@ -0,0 +1,3 @@
+export { Dat } from './Dat';
+export { DatDropdownItem } from './DatDropdownItem';
+export { DatProvider, useTransformations } from './DatContext';

package/Dat/types.d.ts

@@ -0,0 +1,7 @@
+import { Preset } from '@bynder/js-components-lib';
+import { Asset } from '../views/asset/asset.type';
+export interface Transformation {
+    url: string;
+    preset?: Preset;
+    asset: Asset;
+}

package/Main.d.ts

@@ -0,0 +1 @@
+export declare function open(options: Record<string, unknown>): void;

package/__tests__/utils/index.d.ts

@@ -0,0 +1,116 @@
+import { Collection } from '../../views/collection/collection.types';
+import { Asset } from '../../views/asset/asset.type';
+import { MetapropertyType as Metaproperty, Tag } from '../../filter/filters/metaproperty/MetapropertyFilterContent';
+import { MetapropertyOptionType as MetapropertyOption } from '../../filter/filters/metaproperty/MetapropertyOption';
+import { SmartfilterType as Smartfilter } from '../../filter/filters/metaproperty/SmartFilterContent';
+import { File } from '../../select/file.type';
+export declare function mockLocalisation(): void;
+export declare function makeFilterAssetsResponse(...assets: Asset[]): {
+    data: {
+        tag: string;
+        value: {
+            searchAssets: {
+                assets: {
+                    nodes: Asset[];
+                    totalCount: number;
+                };
+            };
+        };
+    };
+};
+export declare function makeAsset(properties: {
+    id: string;
+} & Partial<Asset>): Asset;
+export declare function makeFetchFiltersResponse({ assetTypeCounts, metaproperties, tags, isLoading, }: {
+    assetTypeCounts?: {
+        audio?: number;
+        document?: number;
+        image?: number;
+        video?: number;
+        archive?: number;
+    };
+    metaproperties?: (Metaproperty | Smartfilter)[];
+    tags?: Tag[];
+    isLoading?: boolean;
+}): {
+    data: {
+        tag: string;
+        value: {
+            searchAssets: {
+                count: {
+                    assetType: {
+                        audio: number;
+                        document: number;
+                        image: number;
+                        video: number;
+                        archive: number;
+                    };
+                };
+                metapropertyFilters: {
+                    nodes: (Metaproperty | Smartfilter)[];
+                };
+                tags: {
+                    nodes: Tag[];
+                };
+            };
+        };
+    };
+    isLoading: boolean;
+};
+export declare function makeMetapropertyFilter(properties: {
+    id: string;
+} & Partial<Metaproperty>): {
+    id: string;
+    __typename: "Metaproperty";
+    label: string;
+    zIndex?: number | undefined;
+    options: MetapropertyOption[];
+    showInGridView: boolean;
+    showInListView: boolean;
+};
+export declare function makeMetapropertyOption(properties: {
+    id: string;
+} & Partial<MetapropertyOption>): {
+    id: string;
+    label: string;
+    assetCount: number;
+};
+export declare function makeSmartFilter(properties: {
+    id: string;
+} & Partial<Smartfilter>): Smartfilter;
+export declare function makeTag(properties: {
+    id: string;
+} & Partial<Tag>): {
+    id: string;
+    name: string;
+    assetCount: number;
+};
+export declare function makeFetchCollectionsResponse(...collections: Collection[]): {
+    data: {
+        tag: string;
+        value: {
+            collections: {
+                nodes: Collection[];
+                totalCount: number;
+            };
+        };
+    };
+};
+export declare function makeCollection(properties: {
+    id: string;
+} & Partial<Collection>): Collection;
+export declare function makeGetAssetResponse(asset: {
+    files: Record<string, File>;
+    id?: string;
+}): Promise<import("../../auth/result.type").Ok<{
+    files: Record<string, File>;
+    id?: string | undefined;
+}>>;
+export declare function makeGetAssetsResponse(...assets: Array<{
+    files: Record<string, File>;
+    id?: string;
+}>): Promise<import("../../auth/result.type").Ok<{
+    files: Record<string, File>;
+    id?: string | undefined;
+}[]>>;
+export declare function clickCard(card: HTMLElement, options?: any): void;

package/accesibility/helpers.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare function handleEnter(e: React.KeyboardEvent<Element>, fn?: (e?: any) => void): void;
+export declare function handleSpace(e: React.KeyboardEvent<Element>, fn?: (e?: any) => void): void;

package/api/__tests__/utils.d.ts

@@ -0,0 +1,10 @@
+import { AuthInformationState } from '../../auth/useAuthInformation';
+export declare const mockAuth: AuthInformationState;
+export declare const errorResponse: {
+    errors: {
+        message: string;
+    }[];
+};
+export declare const getSuccessfulResponse: (data: any) => {
+    data: any;
+};

package/api/filterAssets.d.ts

@@ -0,0 +1,42 @@
+import { Result } from '../auth/result.type';
+import { Ordering } from '../order/OrderingContext';
+import { Collection } from '../views/collection/collection.types';
+import { AssetType, Asset } from '../views/asset/asset.type';
+import { Connection } from './graphql.types';
+import { Filter } from '../filter/AssetFilterContext';
+import { AssetFilterJson } from '../filter/assetFilter.type';
+import { MetapropertyType } from '../filter/filters/metaproperty/MetapropertyFilterContent';
+import { AuthInformationState } from '../auth/useAuthInformation';
+interface GraphqlResponse {
+    searchAssets: {
+        assets: Assets;
+    };
+}
+export interface Assets {
+    nodes: Asset[];
+    totalCount: number;
+    pageInfo: {
+        endCursor: string;
+        hasNextPage: boolean;
+    };
+    metaproperties: {
+        nodes: MetapropertyType[];
+    };
+}
+interface Options {
+    allAssetTypes?: AssetType[];
+    collection?: Collection;
+    searchTerm?: string;
+    filter?: Omit<Filter, 'metaproperties' | 'existingFilters'>;
+    predefinedFilter?: AssetFilterJson;
+    orderBy: Ordering;
+    language: string;
+}
+export declare function useFilterAssets(options: Options, noCache?: boolean): Connection<GraphqlResponse>;
+export declare function getAssetsByMediaId(options: {
+    ids: string[];
+    auth: AuthInformationState | null;
+    language: string;
+    noCache?: boolean;
+}): Promise<Result<Asset[], string>>;
+export {};

package/api/getAsset.d.ts

@@ -0,0 +1,15 @@
+import { Result } from '../auth/result.type';
+import { File } from '../select/file.type';
+import { AuthInformationState } from '../auth/useAuthInformation';
+export declare const defaultAssetFieldSelection = "\n    id\n    name\n    description\n    databaseId\n    createdAt\n    originalUrl\n    publishedAt\n    tags\n    type\n    updatedAt\n    url\n    extensions\n    metaproperties {\n      nodes {\n        name\n        type\n        options {\n          name\n          displayLabel\n        }\n      }\n    }\n    textMetaproperties {\n      name\n      value\n    }\n    derivatives {\n      thumbnail\n      webImage\n    }\n    ... on Video {\n      previewUrls\n    }\n";
+export interface Asset {
+    id: string;
+    files: Record<string, File>;
+    databaseId?: string;
+}
+export declare function getAsset(options: {
+    assetId: string;
+    auth: AuthInformationState | null;
+    assetFieldSelection?: string;
+    noCache?: boolean;
+}): Promise<Result<Asset, string>>;

package/api/getAssets.d.ts

@@ -0,0 +1,10 @@
+import { Result } from '../auth/result.type';
+import { SelectedItem } from '../select/SelectionContext';
+import { Asset } from './getAsset';
+import { AuthInformationState } from '../auth/useAuthInformation';
+export declare function getAssets(options: {
+    selectedItems: SelectedItem[];
+    auth: AuthInformationState | null;
+    assetFieldSelection?: string;
+    noCache?: boolean;
+}): Promise<Result<Asset[], string>>;

package/api/getCollections.d.ts

@@ -0,0 +1,18 @@
+import { Ordering } from '../order/OrderingContext';
+import { Collection } from '../views/collection/collection.types';
+import { Connection } from './graphql.types';
+export interface GraphqlResponse {
+    collections: Collections;
+}
+export interface Collections {
+    nodes: Collection[];
+    totalCount: number;
+    pageInfo: {
+        endCursor: string;
+        hasNextPage: boolean;
+    };
+}
+export declare function useGetCollections(options: {
+    searchTerm?: string;
+    orderBy: Ordering;
+}, noCache?: boolean): Connection<GraphqlResponse>;

package/api/getFilters.d.ts

@@ -0,0 +1,33 @@
+import { Data } from './graphql.types';
+import { Tag } from '../filter/filters/metaproperty/MetapropertyFilterContent';
+import { Filter } from '../filter/AssetFilterContext';
+import { AssetType } from '../views/asset/asset.type';
+import { AssetFilterJson } from '@src/filter/assetFilter.type';
+export interface GraphqlFiltersResponse {
+    searchAssets: {
+        count: {
+            assetType: {
+                audio: number;
+                document: number;
+                image: number;
+                video: number;
+                archive: number;
+            };
+        };
+        tags?: {
+            nodes: Tag[];
+        };
+    };
+}
+export declare const query = "\nquery searchAssets($filter: AssetFilter!, $language: String!) {\n    searchAssets(filter: $filter) {\n      tags {\n        nodes {\n          id\n          name\n          assetCount\n        }\n      }\n      count {\n        assetType {\n          image\n          video\n          audio\n          document\n          archive\n        }\n      }\n    }\n  }";
+export declare function useGetFilters(options: {
+    filter: Filter;
+    searchTerm: null | undefined | string;
+    allAssetTypes: AssetType[];
+    language: string;
+    predefinedFilter?: AssetFilterJson;
+    collectionId: string | null;
+}, noCache?: boolean): {
+    data: Data<GraphqlFiltersResponse>;
+    isLoading: boolean;
+};

package/api/graphql.types.d.ts

@@ -0,0 +1,17 @@
+export type Data<T> = {
+    tag: 'Loading';
+    value: null | undefined | T;
+} | {
+    tag: 'Loaded';
+    value: T;
+} | {
+    tag: 'Failure';
+    value: string;
+};
+export interface Connection<T> {
+    data: Data<T>;
+    executeQuery: () => void;
+    isLoading: boolean;
+    loadMore: () => void;
+    hasNextPage: boolean;
+}

package/api/index.d.ts

@@ -0,0 +1,7 @@
+import { AuthInformationState } from '@src/auth/useAuthInformation';
+export declare function fetchWithGraphql(options: {
+    query: string;
+    variables: Record<string, unknown>;
+    auth: AuthInformationState | null;
+    noCache?: boolean;
+}): Promise<import("@src/auth/result.type").Err<any> | import("@src/auth/result.type").Ok<unknown>>;

package/api/rest/autocomplete.d.ts

@@ -0,0 +1,22 @@
+import { AuthInformationState } from '@src/auth/useAuthInformation';
+type AutocompleteOption = {
+    icon: string;
+    id: string;
+    isSelected: boolean;
+    label: string;
+    name: string;
+};
+interface Response {
+    hasNextPage?: boolean;
+    metapropertyOptions?: Array<AutocompleteOption>;
+}
+export interface AutocompleteOptions extends Response {
+    id?: string;
+}
+export declare const getAutocompleteOptions: ({ metapropertyId, auth, searchTerm, page, }: {
+    metapropertyId: string;
+    auth: AuthInformationState | null;
+    searchTerm: string;
+    page?: number | undefined;
+}) => Promise<AutocompleteOptions>;
+export {};

package/api/rest/getAssetCounts.d.ts

@@ -0,0 +1,15 @@
+import { AssetType } from '@src/views/asset/asset.type';
+import { AuthInformationState } from '@src/auth/useAuthInformation';
+import { selectedSmartfilterOptionsType, AssetCountType } from './types';
+export interface AssetFilter {
+    searchTerm?: string;
+    tagNames?: string[];
+    assetTypes?: AssetType[];
+    collectionId?: string;
+    metaproperties?: selectedSmartfilterOptionsType;
+    isLimitedUse?: boolean;
+}
+export declare const getAssetCounts: ({ auth, filter, }: {
+    auth: AuthInformationState | null;
+    filter: AssetFilter;
+}) => Promise<AssetCountType>;

package/api/rest/getInitialFilters.d.ts

@@ -0,0 +1,7 @@
+import { AuthInformationState } from '@src/auth/useAuthInformation';
+export declare const getInitialFilters: ({ auth }: {
+    auth: AuthInformationState | null;
+}) => Promise<{
+    filters: import("./types").Smartfilter[];
+    metaproperties: {};
+}>;

package/api/rest/getMetapropertiesOptions.d.ts

@@ -0,0 +1,12 @@
+import { AuthInformationState } from '@src/auth/useAuthInformation';
+import { SmartfilterMetaproperty } from './types';
+type OptionsRequestType = {
+    auth: AuthInformationState | null;
+    metapropertyId: string;
+    smartfilterId: string;
+    labelKeyset: string;
+    zindexKeyset: number;
+    mpoKeyset: string;
+};
+export declare const getMetapropertiesOptions: ({ auth, smartfilterId, metapropertyId, labelKeyset, zindexKeyset, mpoKeyset, }: OptionsRequestType) => Promise<SmartfilterMetaproperty>;
+export {};

package/api/rest/handlers.d.ts

@@ -0,0 +1,7 @@
+export declare const handlers: {
+    smartfilters: string;
+    metaproperties: string;
+    autocomplete: string;
+    options: (id: string) => string;
+    metapropertiesWithOptions: (smartfilterId: string, metapropertyId: string) => string;
+};

package/api/rest/index.d.ts

@@ -0,0 +1,6 @@
+import { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios';
+export declare const onSuccess: <T>(response: AxiosResponse<T, any>) => T;
+export declare const onError: (error: AxiosError) => never;
+declare const getRequest: <T>(endpoint: string, params?: AxiosRequestConfig) => Promise<T>;
+declare const postRequest: <T>(endpoint: string, data: unknown, config?: AxiosRequestConfig) => Promise<T>;
+export { getRequest, postRequest };

package/api/rest/types.d.ts

@@ -0,0 +1,66 @@
+export type Smartfilter = {
+    icon: string;
+    labels: Record<string, string>;
+    zindex: number;
+    id: string;
+    metaproperties: string[];
+};
+export type SmartfilterResponse = Smartfilter[];
+export type SmartfilterOption = {
+    count: number;
+    zindex: number;
+    name: string;
+    id: string;
+    isSelected: boolean;
+    label: string;
+    icon?: string;
+};
+export type SmartfilterSelectedOptionType = Pick<SmartfilterOption, 'id' | 'label'> & {
+    metapropertyName: string;
+};
+export type SmartfilterMetaproperty = {
+    dependencyId: string;
+    isMultifilter: number;
+    options: SmartfilterOption[];
+    showImage: boolean;
+    isMainFilter: boolean;
+    zindex: number;
+    showCounter: boolean;
+    name: string;
+    id: string;
+    showFilterToGetAssetsWithoutMetaproperty: boolean;
+    type: string;
+    label: string;
+    numberOfOptions: number;
+};
+export type AutocompleteOption = {
+    count: number;
+    zindex: number;
+    name: string;
+    id: string;
+    isSelected: boolean;
+    label: string;
+    icon?: string;
+};
+export type AutcompleteResponseOption = {
+    dependencyId: string;
+    isMultifilter: number;
+    options: AutocompleteOption[];
+    showImage: boolean;
+    isMainFilter: boolean;
+    zindex: number;
+    showCounter: boolean;
+    name: string;
+    id: string;
+    showFilterToGetAssetsWithoutMetaproperty: boolean;
+    type: string;
+    label: string;
+    numberOfOptions: number;
+};
+export type selectedSmartfilterOptionsType = Record<string, Record<string, SmartfilterSelectedOptionType>>;
+type Count = Record<string, number>;
+export type AssetCountType = {
+    count: Record<string, Count>;
+    media: string[];
+};
+export {};

package/app-config/ConfigContext.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { Config as ProvidedConfig, SelectionMode } from './appConfig.type';
+type Config = Required<Pick<ProvidedConfig, 'language' | 'onSuccess' | 'assetTypes'>> & Pick<ProvidedConfig, 'assetFieldSelection' | 'assetFilter' | 'hideExternalAccess' | 'theme' | 'mode' | 'hideSwitch' | '__shouldAddOriginal__' | 'noCache' | 'selectAllOption'> & {
+    selectionMode: SelectionMode;
+};
+export declare const defaultConfig: Config;
+export declare const ConfigProvider: import("react").Provider<Config>;
+export declare const useConfig: () => Config;
+export declare const useTheme: () => import("..").theme | undefined;
+export declare const useAssetFilter: () => import("..").assetFilter | undefined;
+export declare const useSelectionMode: () => SelectionMode;
+export declare const useHideSwitch: () => boolean | undefined;
+export {};

package/app-config/appConfig.type.d.ts

@@ -0,0 +1,46 @@
+import { Theme } from '../style/Theming';
+import { File } from '../select/file.type';
+import { AssetFilterJson } from '../filter/assetFilter.type';
+import { AssetType } from '../views/asset/asset.type';
+export type AdditionalInfo = {
+    selectedFile?: File;
+};
+export type OnSuccessCallback = (assets: unknown[], additionalInfo: AdditionalInfo) => void;
+export type SelectionMode = 'SingleSelect' | 'SingleSelectFile' | 'MultiSelect';
+export interface PortalConfig {
+    url: string;
+    editable?: boolean;
+}
+/**
+ * When starting the app or tests a .guard.ts file will be generated. This file
+ * will contain a method which is able to validate if a variable is consistent
+ * with the Config type.
+ */
+/** @see {validateConfig} ts-auto-guard:type-guard */
+export interface Config {
+    assetFieldSelection?: string;
+    assetFilter?: AssetFilterJson;
+    assetTypes?: AssetType[];
+    container?: HTMLElement;
+    language?: string;
+    onSuccess?: OnSuccessCallback;
+    mode?: SelectionMode;
+    portal?: PortalConfig;
+    defaultSearchTerm?: string;
+    theme?: Theme;
+    hideExternalAccess?: boolean;
+    selectedAssets?: string[];
+    authentication?: {
+        getAccessToken: () => string;
+        hideLogout?: boolean;
+    };
+    onLogout?: () => void;
+    hideLimitedUse?: boolean;
+    modalStyles?: {
+        [key: string]: string;
+    };
+    hideSwitch?: boolean;
+    __shouldAddOriginal__?: boolean;
+    noCache?: boolean;
+    selectAllOption?: boolean;
+}

package/app-config/appConfig.type.guard.d.ts

@@ -0,0 +1,2 @@
+import { Config } from "./appConfig.type";
+export declare function validateConfig(obj: any, argumentName?: string): obj is Config;

package/auth/auth.d.ts

@@ -0,0 +1,7 @@
+import { Result } from './result.type';
+export interface AuthenticationResponse {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+}
+export declare function authenticate(accountDomain: string): Promise<Result<AuthenticationResponse, string>>;

package/auth/crypto.d.ts

@@ -0,0 +1,3 @@
+export declare function base64URLEncode(str: ArrayBuffer): string;
+export declare function sha256(s: string): Promise<ArrayBuffer>;
+export declare function randomString(): string;

package/auth/loginwindow.d.ts

@@ -0,0 +1,7 @@
+import { Result } from './result.type';
+interface LoginWindowResponse {
+    state: string | null;
+    code: string | null;
+}
+export declare function waitForAuthorizationFromLoginWindow(url: string): Promise<Result<LoginWindowResponse, string>>;
+export {};

package/auth/oauth2.d.ts

@@ -0,0 +1,16 @@
+import { Result } from './result.type';
+export declare const redirectOrigin: string;
+export type AuthPlatform = 'bynder' | 'webdam' | 'invalid';
+export declare function makeAuthorizeRequestUrl(codeChallenge: string, state: string, accountDomain: string): string;
+interface TokenRequest {
+    refreshToken: string;
+    accessToken: string;
+    expiresIn: string;
+}
+export declare function postTokenRequest(code: string, code_verifier: string, accountDomain: string): Promise<Result<TokenRequest, string>>;
+interface RefreshTokenRequest {
+    accessToken: string;
+    expiresIn: number;
+}
+export declare function postRefreshTokenRequest(refreshToken: string, accountDomain: string): Promise<Result<RefreshTokenRequest, string>>;
+export {};

package/auth/result.type.d.ts

@@ -0,0 +1,13 @@
+export type Ok<T> = {
+    tag: 'ok';
+    value: T;
+};
+export interface Err<E> {
+    tag: 'error';
+    error: E;
+}
+export type Result<T, E> = Ok<T> | Err<E>;
+export declare function ok<T>(value: T): Ok<T>;
+export declare function err<E>(error: E): Err<E>;
+export declare function isOk<T, E = unknown>(result: Result<T, E>): result is Ok<T>;
+export declare function isErr<E, T = unknown>(result: Result<T, E>): result is Err<E>;