@equinor/subsurface-app-management 1.0.0 → 1.0.1

package/dist/types/api/models/ServiceNowUrgency.d.ts

@@ -0,0 +1,5 @@
+export declare enum ServiceNowUrgency {
+    CRITICAL = "Critical",
+    MODERATE = "Moderate",
+    NORMAL = "Normal"
+}

package/dist/types/api/models/Tutorial.d.ts

@@ -0,0 +1,13 @@
+import { CustomTutorialStep } from './CustomTutorialStep';
+import { GenericTutorialStep } from './GenericTutorialStep';
+export type Tutorial = {
+    id: string;
+    name: string;
+    shortName: string;
+    path: string;
+    application: string;
+    steps: Array<CustomTutorialStep | GenericTutorialStep>;
+    showInProd: boolean;
+    willPopUp: boolean;
+    dynamicPositioning?: boolean | null;
+};

package/dist/types/api/models/TutorialPosition.d.ts

@@ -0,0 +1,7 @@
+export declare enum TutorialPosition {
+    TOP_LEFT = "TOP_LEFT",
+    TOP_RIGHT = "TOP_RIGHT",
+    BOTTOM_LEFT = "BOTTOM_LEFT",
+    BOTTOM_RIGHT = "BOTTOM_RIGHT",
+    CENTER = "CENTER"
+}

package/dist/types/api/models/TutorialStepBase.d.ts

@@ -0,0 +1,4 @@
+import type { TutorialPosition } from './TutorialPosition';
+export type TutorialStepBase = {
+    position?: TutorialPosition;
+};

package/dist/types/api/services/PortalService.d.ts

@@ -0,0 +1,35 @@
+import type { CancelablePromise } from '../';
+import { FeatureToggleDto } from '../';
+import { ServiceNowIncidentResponse } from 'src/api/models/ServiceNowIncidentResponse';
+import { AmplifyApplication } from '../models/Applications';
+export declare class PortalService {
+    /**
+     * Creates a incident report in service now
+     * @param formData
+     * @returns any Success
+     * @throws ApiError
+     */
+    static createIncident(formData?: FormData): CancelablePromise<ServiceNowIncidentResponse>;
+    /**
+     * Uploads file to slack and links it to a channel defined in config
+     * @param formData
+     * @returns any Success
+     * @throws ApiError
+     */
+    static fileUpload(formData?: FormData): CancelablePromise<unknown>;
+    /**
+     * Posts a slack message to channel defined in config
+     * @param formData
+     * @returns any Success
+     * @throws ApiError
+     */
+    static postmessage(formData?: FormData): CancelablePromise<unknown>;
+    /**
+     * Gets a Feature Toggle from Application name
+     * @param applicationName name
+     * @returns FeatureToggleDto Success
+     * @throws ApiError
+     */
+    static getFeatureToggleFromApplicationName(applicationName: string): CancelablePromise<FeatureToggleDto>;
+    static userApplications(): CancelablePromise<Array<AmplifyApplication>>;
+}

package/dist/types/api/services/ReleaseNotesService.d.ts

@@ -0,0 +1,28 @@
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class ReleaseNotesService {
+    /**
+     * @param applicationName
+     * @param version
+     * @param tags
+     * @returns any Success
+     * @throws ApiError
+     */
+    static getReleasenoteList(applicationName?: string, version?: string, tags?: Array<string>): CancelablePromise<any>;
+    /**
+     * @returns any Success
+     * @throws ApiError
+     */
+    static getMyReleasenotes(): CancelablePromise<any>;
+    /**
+     * @param applicationName
+     * @param releaseId
+     * @returns any Success
+     * @throws ApiError
+     */
+    static getReleasenote(applicationName: string, releaseId: string): CancelablePromise<any>;
+    /**
+     * @returns string Success
+     * @throws ApiError
+     */
+    static getContainerSasUri(): CancelablePromise<string>;
+}

package/dist/types/api/services/TutorialService.d.ts

@@ -0,0 +1,12 @@
+import type { Tutorial } from '../models/Tutorial';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class TutorialService {
+    /**
+     * Gets all tutorials for Application
+     * @param applicationName
+     * @returns Tutorial Success
+     * @throws ApiError
+     */
+    static getTutorialsForApplication(applicationName: string): CancelablePromise<Array<Tutorial>>;
+    static getTutorialSasToken(): CancelablePromise<string>;
+}

package/dist/types/components/Feature/Feature.d.ts

@@ -0,0 +1,9 @@
+import { DetailedHTMLProps, FC, HTMLAttributes, ReactNode } from 'react';
+interface FeatureProps {
+    featureKey: string;
+    children: ReactNode;
+    fallback?: DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>;
+    showIfKeyMissing?: boolean;
+}
+export declare const Feature: FC<FeatureProps>;
+export {};

package/dist/types/components/index.d.ts

@@ -0,0 +1 @@
+export { Feature } from './Feature/Feature';

package/dist/types/hooks/index.d.ts

@@ -0,0 +1,6 @@
+import { useAuth } from '../providers/AuthProvider/AuthProvider';
+import { useTutorialSteps } from '../providers/TutorialStepsProvider';
+import { useFeatureToggling } from './useFeatureToggling';
+import { useReleaseNotesQuery } from './useReleaseNotesQuery';
+import { useSignalRMessages } from './useSignalRMessages';
+export { useAuth, useFeatureToggling, useReleaseNotesQuery, useSignalRMessages, useTutorialSteps, };

package/dist/types/hooks/useFeatureToggling.d.ts

@@ -0,0 +1,3 @@
+export declare function useFeatureToggling(featureKey: string, showIfKeyMissing?: boolean): {
+    showContent: boolean;
+};

package/dist/types/hooks/useReleaseNotesQuery.d.ts

@@ -0,0 +1,6 @@
+import { ReleaseNote } from 'src/api/models/ReleaseNote';
+interface ReleaseNotesQueryProps {
+    enabled?: boolean;
+}
+export declare function useReleaseNotesQuery(options?: ReleaseNotesQueryProps): import("@tanstack/react-query").UseQueryResult<ReleaseNote[], Error>;
+export {};

package/dist/types/hooks/useSignalRMessages.d.ts

@@ -0,0 +1,12 @@
+export declare function useSignalRMessages<T extends {
+    SequenceNumber?: number | null;
+    Read?: boolean | null;
+    Subject?: string | null;
+}>(topic: string): {
+    messages: T[];
+    hasUnreadMessages: boolean;
+    setMessageAsRead: (message: T) => void;
+    setAllMessagesAsRead: () => void;
+    deleteMessage: (message: T) => Promise<void>;
+    closeConnection: () => Promise<void>;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './components';
+export * from './hooks';
+export * from './providers';
+export * from './types';
+export * from './utils';

package/dist/types/providers/AuthProvider/AuthProvider.d.ts

@@ -0,0 +1,17 @@
+import { FC, ReactElement, ReactNode } from 'react';
+import { AccountInfo } from '@azure/msal-browser';
+export type AuthState = 'loading' | 'authorized' | 'unauthorized';
+export interface AuthContextType {
+    account: AccountInfo | undefined;
+    photo: string | undefined;
+    roles: string[] | undefined;
+    logout: () => void;
+}
+export declare const useAuth: () => AuthContextType;
+interface AuthProviderProps {
+    children: ReactNode;
+    loadingComponent?: ReactElement;
+    unauthorizedComponent?: ReactElement;
+}
+declare const AuthProvider: FC<AuthProviderProps>;
+export default AuthProvider;

package/dist/types/providers/AuthProvider/AuthProviderInner.d.ts

@@ -0,0 +1,16 @@
+import { FC, ReactElement, ReactNode } from 'react';
+import { AccountInfo } from '@azure/msal-common';
+import { AuthState } from './AuthProvider';
+export interface AuthProviderInnerProps {
+    children: ReactNode;
+    account: AccountInfo | undefined;
+    setAccount: (val: AccountInfo | undefined) => void;
+    setPhoto: (val: string | undefined) => void;
+    setRoles: (val: string[] | undefined) => void;
+    authState: AuthState;
+    setAuthState: (val: AuthState) => void;
+    loadingComponent?: ReactElement;
+    unauthorizedComponent?: ReactElement;
+}
+declare const AuthProviderInner: FC<AuthProviderInnerProps>;
+export default AuthProviderInner;

package/dist/types/providers/FeatureToggleProvider.d.ts

@@ -0,0 +1,14 @@
+import { FC, ReactNode } from 'react';
+import { Feature, GraphUser } from '../api';
+export declare const isUserInActiveUserArray: (username: string, activeUsers: GraphUser[] | undefined | null) => boolean;
+interface FeatureToggleContextType {
+    isLoading: boolean;
+    isError: boolean;
+    features?: Feature[] | null;
+}
+export declare function useFeatureToggleContext(): FeatureToggleContextType;
+interface FeatureToggleProviderProps {
+    children: ReactNode;
+}
+declare const FeatureToggleProvider: FC<FeatureToggleProviderProps>;
+export default FeatureToggleProvider;

package/dist/types/providers/ReleaseNotesProvider.d.ts

@@ -0,0 +1,20 @@
+import { Dispatch, FC, ReactNode, SetStateAction } from 'react';
+import { Option, SieveValue, TableOfContentsItemType } from '@equinor/amplify-components';
+import { ReleaseNote } from 'src/api/models/ReleaseNote';
+interface ReleaseNotesContextState {
+    search: SieveValue;
+    setSearch: Dispatch<SetStateAction<SieveValue>>;
+    selectedReleaseNoteTypes?: Option[];
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    toggle: () => void;
+    filteredData: ReleaseNote[];
+    releaseNotesYears: TableOfContentsItemType[];
+}
+export declare const useReleaseNotes: () => ReleaseNotesContextState;
+interface ReleaseNotesContextProviderProps {
+    children: ReactNode;
+    enabled?: boolean;
+}
+declare const ReleaseNotesProvider: FC<ReleaseNotesContextProviderProps>;
+export default ReleaseNotesProvider;

package/dist/types/providers/TutorialProvider/TutorialDialog.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+declare const TutorialDialog: FC;
+export default TutorialDialog;

package/dist/types/providers/TutorialProvider/TutorialProvider.const.d.ts

@@ -0,0 +1,7 @@
+export declare const HIGHLIGHT_PADDING = 8;
+export declare const DIALOG_EDGE_MARGIN = 24;
+export declare const TUTORIAL_SEARCH_PARAM_KEY = "tutorial";
+export declare const TUTORIAL_LOCALSTORAGE_VALUE_STRING = "hasCompletedTutorial";
+export declare const TUTORIAL_HIGHLIGHTER_DATATEST_ID = "tutorial-highlighter";
+export declare const GET_TUTORIALS_FOR_APP = "getTutorialsForApp";
+export declare const GET_TUTORIALS_SAS_TOKEN = "getTutorialsSasToken";

package/dist/types/providers/TutorialProvider/TutorialProvider.d.ts

@@ -0,0 +1,30 @@
+import { Dispatch, FC, MutableRefObject, ReactNode, SetStateAction } from 'react';
+import { CustomTutorialComponent } from './TutorialProvider.types';
+import { CustomTutorialStep, GenericTutorialStep, Tutorial } from 'src/api';
+export interface TutorialContextType {
+    activeTutorial: Tutorial | undefined;
+    setActiveTutorial: Dispatch<SetStateAction<Tutorial | undefined>>;
+    currentStep: number;
+    setCurrentStep: Dispatch<SetStateAction<number>>;
+    allElementsToHighlight: HTMLElement[] | undefined;
+    setAllElementsToHighlight: Dispatch<SetStateAction<HTMLElement[] | undefined>>;
+    customStepComponents: CustomTutorialComponent[] | undefined;
+    currentStepObject: GenericTutorialStep | CustomTutorialStep | undefined;
+    isLastStep: boolean;
+    dialogRef: MutableRefObject<HTMLDialogElement | null>;
+    clearSearchParam: () => void;
+    shortNameFromParams: string | undefined;
+    setShortNameFromParams: Dispatch<SetStateAction<string | undefined>>;
+    tutorialsFromProps: Tutorial[];
+    tutorialError: boolean;
+    setTutorialError: Dispatch<SetStateAction<boolean>>;
+    viewportWidth: number;
+}
+export declare const TutorialContext: import("react").Context<TutorialContextType | undefined>;
+interface TutorialProviderProps {
+    children: ReactNode;
+    customStepComponents?: CustomTutorialComponent[];
+    tutorials?: Tutorial[];
+}
+declare const TutorialProvider: FC<TutorialProviderProps>;
+export default TutorialProvider;

package/dist/types/providers/TutorialProvider/TutorialProvider.hooks.d.ts

@@ -0,0 +1,3 @@
+export declare const useGetTutorialsForApp: () => import("@tanstack/react-query").UseQueryResult<import("../../api").Tutorial[], Error>;
+export declare const useGetTutorialSasToken: () => import("@tanstack/react-query").UseQueryResult<string, Error>;
+export declare const useTutorial: () => import("src/providers/TutorialProvider/TutorialProvider").TutorialContextType;

package/dist/types/providers/TutorialProvider/TutorialProvider.styles.d.ts

@@ -0,0 +1,26 @@
+export declare const Highlighter: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const DialogWrapper: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const StyledTutorialDialog: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").DialogHTMLAttributes<HTMLDialogElement>, HTMLDialogElement>, never>> & string;
+export declare const DialogContent: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const DialogImage: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, never>> & string;
+export declare const DialogActions: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const NavigateSteps: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & string;
+export declare const TutorialErrorDialog: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<{
+    isDismissable?: boolean;
+    open: boolean;
+    onClose?: () => void;
+    dialogRef?: import("react").ForwardedRef<HTMLDialogElement>;
+} & import("react").HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import("react").DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}, never>> & string & Omit<import("react").ForwardRefExoticComponent<{
+    isDismissable?: boolean;
+    open: boolean;
+    onClose?: () => void;
+    dialogRef?: import("react").ForwardedRef<HTMLDialogElement>;
+} & import("react").HTMLAttributes<HTMLDivElement> & import("react").RefAttributes<HTMLDivElement>> & {
+    Actions: typeof import("@equinor/eds-core-react/dist/types/components/Dialog/DialogActions").DialogActions;
+    Title: typeof import("@equinor/eds-core-react/dist/types/components/Dialog/DialogTitle").DialogTitle;
+    CustomContent: typeof import("@equinor/eds-core-react/dist/types/components/Dialog/DialogContent").DialogContent;
+    Content: typeof import("@equinor/eds-core-react/dist/types/components/Dialog/DialogContent").DialogContent;
+    Header: typeof import("@equinor/eds-core-react/dist/types/components/Dialog/DialogHeader").DialogHeader;
+}, keyof import("react").Component<any, {}, any>>;

package/dist/types/providers/TutorialProvider/TutorialProvider.types.d.ts

@@ -0,0 +1,11 @@
+import { ReactElement } from 'react';
+export interface HighlightingInfo {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export interface CustomTutorialComponent {
+    key: string;
+    element: ReactElement;
+}

package/dist/types/providers/TutorialProvider/TutorialProvider.utils.d.ts

@@ -0,0 +1,3 @@
+import { Tutorial, TutorialPosition } from 'src/api';
+export declare const getBestPositionWithoutOverlap: (highlightedBoundingRect: DOMRect, dialogBoundingRect: DOMRect) => TutorialPosition.TOP_LEFT | TutorialPosition.TOP_RIGHT | TutorialPosition.BOTTOM_LEFT | TutorialPosition.BOTTOM_RIGHT;
+export declare const getAllElementsToHighlight: (activeTutorial: Tutorial) => (HTMLElement | null)[];

package/dist/types/providers/TutorialProvider/TutorialProviderInner.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+declare const TutorialProviderInner: FC;
+export default TutorialProviderInner;

package/dist/types/providers/TutorialProvider/TutorialStepIndicator.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+import { CustomTutorialStep, GenericTutorialStep } from 'src/api';
+interface TutorialStepIndicatorProps {
+    steps: (GenericTutorialStep | CustomTutorialStep)[];
+    currentStep: number;
+}
+declare const TutorialStepIndicator: FC<TutorialStepIndicatorProps>;
+export default TutorialStepIndicator;

package/dist/types/providers/TutorialStepsProvider.d.ts

@@ -0,0 +1,13 @@
+import { FC, ReactNode } from 'react';
+interface TutorialContextState {
+    tutorialStep: string;
+    setTutorialStep: (val: string) => void;
+    showTutorialIntro: boolean;
+    setShowTutorialIntro: (val: boolean) => void;
+}
+export declare const useTutorialSteps: () => TutorialContextState;
+declare const TutorialStepsProvider: FC<{
+    children: ReactNode;
+    startOpen?: boolean;
+}>;
+export default TutorialStepsProvider;

package/dist/types/providers/index.d.ts

@@ -0,0 +1,5 @@
+import AuthProvider from './AuthProvider/AuthProvider';
+import TutorialProvider from './TutorialProvider/TutorialProvider';
+import FeatureToggleProvider from './FeatureToggleProvider';
+import TutorialStepsProvider from './TutorialStepsProvider';
+export { AuthProvider, FeatureToggleProvider, TutorialProvider, TutorialStepsProvider, };

package/dist/types/storybook/InfoCard.d.ts

@@ -0,0 +1,8 @@
+interface InfoCardTypes {
+    title?: string;
+    description?: string;
+    url?: string;
+    urlTitle?: string;
+}
+export declare const InfoCard: ({ title, description, url, urlTitle, }: InfoCardTypes) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/storybook/Links.d.ts

@@ -0,0 +1,9 @@
+interface LinksProps {
+    figmaUrl?: string;
+    ariaUrl?: string;
+    documentationUrl?: string;
+    sourceUrl?: string;
+    edsSBUrl?: string;
+}
+export declare const Links: ({ ariaUrl, figmaUrl, documentationUrl, sourceUrl, edsSBUrl, }: LinksProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/storybook/PropsTable.d.ts

@@ -0,0 +1,10 @@
+import PropTypes from 'prop-types';
+export declare const PropsTable: {
+    ({ story, ...props }: {
+        [x: string]: any;
+        story?: string | undefined;
+    }): import("react/jsx-runtime").JSX.Element;
+    propTypes: {
+        story: PropTypes.Requireable<string>;
+    };
+};

package/dist/types/storybook/Stack.d.ts

@@ -0,0 +1,9 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { CSSObject } from 'styled-components';
+type StackProps = {
+    direction?: CSSObject['flexDirection'];
+    align?: CSSObject['alignItems'];
+    children: ReactNode;
+} & HTMLAttributes<HTMLDivElement>;
+export declare const Stack: ({ children, direction, align, ...rest }: StackProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/storybook/Story.d.ts

@@ -0,0 +1,2 @@
+import { StoryProps } from '@storybook/addon-docs';
+export declare const Story: (props: StoryProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/storybook/index.d.ts

@@ -0,0 +1,5 @@
+export { InfoCard } from './InfoCard';
+export { Links } from './Links';
+export { PropsTable } from './PropsTable';
+export { Stack } from './Stack';
+export { Story } from './Story';

package/dist/types/tests/browserMocks.d.ts

@@ -0,0 +1,24 @@
+import { Mock } from 'vitest';
+export declare class ClipboardDataMock {
+    getData: Mock<string[], [string]>;
+    setData: Mock<string[], [string, string]>;
+    constructor();
+}
+export declare class ClipboardEventMock extends Event {
+    clipboardData: ClipboardDataMock;
+    constructor(type: string, options?: EventInit);
+}
+export declare class DataTransferMock {
+    data: Record<string, string>;
+    constructor();
+    setData(format: string, data: string): void;
+    getData(format: string): string;
+}
+export declare class DragEventMock extends Event {
+    dataTransfer: DataTransferMock;
+    constructor(type: string, options?: EventInit);
+}
+export declare function mockGetBoundingClientRect(): DOMRect;
+export declare class FakeDOMRectList extends Array<DOMRect> implements DOMRectList {
+    item(index: number): DOMRect | null;
+}

package/dist/types/tests/setupTests.d.ts

@@ -0,0 +1,2 @@
+import '@testing-library/jest-dom';
+import 'jest-styled-components';

package/dist/types/tests/test-utils.d.ts

@@ -0,0 +1,6 @@
+import { ReactElement } from 'react';
+import { render, RenderOptions } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+declare const customRender: (ui: ReactElement, options?: RenderOptions) => ReturnType<typeof render>;
+export * from '@testing-library/react';
+export { customRender as render, userEvent };

package/dist/types/types/Environment.d.ts

@@ -0,0 +1,6 @@
+export declare enum EnvironmentType {
+    LOCALHOST = "localhost",
+    DEVELOP = "development",
+    STAGING = "staging",
+    PRODUCTION = "production"
+}

package/dist/types/types/ReleaseNotes.d.ts

@@ -0,0 +1,19 @@
+declare enum ReleaseNoteType {
+    FEATURE = "Feature",
+    IMPROVEMENT = "Improvement",
+    BUG_FIX = "Bug fix"
+}
+type ReleaseNoteTypeInformation = {
+    [key in ReleaseNoteType]: {
+        dotColor: string;
+    };
+};
+declare const RELEASENOTE_TYPES_INFORMATION: ReleaseNoteTypeInformation;
+interface ReleaseNotesTypesProps {
+    name: ReleaseNoteType;
+    onClick?: () => void;
+    active?: boolean;
+    showIcon: boolean;
+}
+export { ReleaseNoteType, RELEASENOTE_TYPES_INFORMATION };
+export type { ReleaseNotesTypesProps };

package/dist/types/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Environment';
+export * from './ReleaseNotes';

package/dist/types/utils/UtilStory.d.ts

@@ -0,0 +1,7 @@
+import { FC } from 'react';
+interface UtilStoryProps {
+    name: string;
+    codeText: string;
+}
+declare const UtilStory: FC<UtilStoryProps>;
+export default UtilStory;

package/dist/types/utils/auth_environment.d.ts

@@ -0,0 +1,47 @@
+import { PublicClientApplication } from '@azure/msal-browser';
+import { EnvironmentType } from 'src/types/Environment';
+interface EnvVariables {
+    CLIENT_ID: string;
+    NAME: string;
+    API_URL: string;
+    API_SCOPE: string;
+    ENVIRONMENT_NAME: string;
+    SERVICE_NOW_CONFIGURATION_ITEM: string;
+    ALLOWED_PARENT_DOMAINS: string;
+}
+export declare const auth: {
+    fetchMsGraph: (url: string, accessToken: string) => Promise<Response>;
+    GRAPH_SCOPES: {
+        OPENID: string;
+        PROFILE: string;
+        USER_READ: string;
+    };
+    GRAPH_REQUESTS_LOGIN: {
+        scopes: string[];
+    };
+    GRAPH_REQUESTS_PHOTO: {
+        scopes: string[];
+    };
+    GRAPH_REQUESTS_BACKEND: (apiScope: string) => {
+        scopes: string[];
+    };
+    GRAPH_ENDPOINTS: {
+        PHOTO: string;
+    };
+    msalApp: PublicClientApplication;
+    getToken: () => Promise<string>;
+    isReaderOnly: (roles: string[] | undefined) => boolean;
+    isInIframe: () => boolean;
+};
+export declare const environment: {
+    getConfig: (param: keyof EnvVariables) => string;
+    getAppName: (appName: string | undefined) => string;
+    getClientId: (clientId: string | undefined) => string;
+    getApiUrl: (apiUrl: string | undefined) => string;
+    getApiScope: (apiScope: string | undefined) => string;
+    getEnvironmentName: (environmentName: string | EnvironmentType | undefined) => EnvironmentType;
+    getIsMock: (isMock: string | undefined) => boolean;
+    getServiceNowConfigurationItem: (configurationItem: string | undefined) => string;
+    PORTAL_URL_WITHOUT_LOCALHOST: string;
+};
+export {};

package/dist/types/utils/index.d.ts

@@ -0,0 +1,2 @@
+import { auth, environment } from './auth_environment';
+export { auth, environment };

package/dist/types/utils/localStorage.d.ts

@@ -0,0 +1,2 @@
+export declare const getLocalStorage: <T>(key: string, defaultState: T) => T;
+export declare const updateLocalStorage: <T>(key: string, state: T) => void;

package/dist/types/utils/releaseNotes.d.ts

@@ -0,0 +1,8 @@
+import { TableOfContentsItemType } from '@equinor/amplify-components';
+import { ReleaseNote } from 'src/api/models/ReleaseNote';
+declare const extractDatesFromReleaseNotes: (releaseNotes: ReleaseNote[]) => TableOfContentsItemType[];
+declare const monthValueToString: (monthValue: Date) => string;
+declare const monthToString: (monthValue: Date) => string;
+declare const yearValueToString: (yearValue: Date) => string;
+declare const sortReleaseNotesByDate: (notes: ReleaseNote[]) => ReleaseNote[];
+export { extractDatesFromReleaseNotes, monthToString, monthValueToString, sortReleaseNotesByDate, yearValueToString, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/subsurface-app-management",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "React Typescript components/hooks to communicate with equinor/sam",
   "main": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",