@equinor/roma-framework 1.0.0 → 1.1.0

package/dev-portal/index.d.ts

@@ -0,0 +1,15 @@
+export * from './lib/make-component';
+export * from './lib/dev-portal/EquinorLoader';
+export * from './lib/dev-portal/ErrorViewer';
+export * from './lib/dev-portal/AppLoader';
+export * from './lib/dev-portal/AppViewer';
+export * from './lib/dev-portal/Header';
+export * from './lib/style-provider';
+export * from './lib/dev-portal/HttpErrorViewer';
+export * from './lib/api/roma';
+export * from './lib/api/ms-graph';
+export * from './lib/app-provider';
+export * from './lib/query/persister';
+export * from './lib/hooks/use-get-api-roles';
+export * from './lib/hooks/use-has-api-role';
+export * from './lib/error-handlers/http-error-handler';

package/dev-portal/lib/api/fetcher.d.ts

@@ -0,0 +1,21 @@
+export interface HttpErrorServerResponse {
+    timestamp: string;
+    status: number;
+    error: string;
+    message: string;
+    path: string;
+}
+export interface HttpErrorResponse {
+    status: number;
+    statusText: string;
+    message: HttpErrorServerResponse;
+    ok: boolean;
+    headers: Headers;
+    url: string;
+}
+export declare class HttpError extends Error {
+    readonly message: string;
+    readonly response: HttpErrorResponse;
+    constructor(message: string, response: HttpErrorResponse);
+}
+export declare const handleJsonRequest: <T>(req: Response) => Promise<T>;

package/dev-portal/lib/api/ms-graph/api/group/find-group-members.d.ts

@@ -0,0 +1,2 @@
+import { AzureResponse } from '../../model/azure-response';
+export declare const useFindGroupMembers: (groupId: string, query?: string) => import('@tanstack/react-query').UseQueryResult<AzureResponse<["displayName", "id"]>, Error>;

package/dev-portal/lib/api/ms-graph/api/user/find-user-by-shortname.d.ts

@@ -0,0 +1 @@
+export declare const useFindUsersByShortname: (shortnames: Array<string> | string, fields?: readonly ["displayName", "mail", "givenName"]) => import('@tanstack/react-query').UseQueryResult<import('../..').AzureResponse<readonly ("displayName" | "mail" | "givenName")[]>, Error>;

package/dev-portal/lib/api/ms-graph/api/user/find-users-by-mail.d.ts

@@ -0,0 +1,2 @@
+import { AzureResponse } from '../../model/azure-response';
+export declare const useFindUsersByMail: (email: Array<string> | string, fields?: readonly ["displayName", "mail", "givenName"]) => import('@tanstack/react-query').UseQueryResult<AzureResponse<readonly ("displayName" | "mail" | "givenName")[]>, Error>;

package/dev-portal/lib/api/ms-graph/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * API Methods
+ */
+export * from './api/group/find-group-members';
+export * from './api/user/find-user-by-shortname';
+export * from './api/user/find-users-by-mail';
+/**
+ * API Models
+ */
+export * from './model/azure-response';

package/dev-portal/lib/api/ms-graph/model/azure-response.d.ts

@@ -0,0 +1,7 @@
+export type AzureResponse<Fields extends ReadonlyArray<string>> = {
+    '@odata.context': string;
+    '@odata.number': number;
+    value: Array<{
+        [K in Fields extends ReadonlyArray<infer U> ? U : never]: string;
+    }>;
+};

package/dev-portal/lib/api/ms-graph/model/error.d.ts

@@ -0,0 +1,11 @@
+export type GraphError = {
+    error: {
+        code: string;
+        message: string;
+        innerError: {
+            date: string;
+            'request-id': string;
+            'client-request-id': string;
+        };
+    };
+};

package/dev-portal/lib/api/roma/api/app-controller/app-controller.d.ts

@@ -0,0 +1,121 @@
+import { QueryKey, UseMutationOptions, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { AppDto, GetAllApps200, UploadBundleBody } from '../../model';
+import { ErrorType, BodyType } from '../../use-client';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+/**
+ * @summary Upload an application bundle file
+ */
+export declare const useUploadBundleHook: () => (key: string, uploadBundleBody: BodyType<UploadBundleBody>) => Promise<void>;
+export declare const useUploadBundleMutationOptions: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUploadBundleHook>>>, TError, {
+        key: string;
+        data: BodyType<UploadBundleBody>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUploadBundleHook>>>, TError, {
+    key: string;
+    data: BodyType<UploadBundleBody>;
+}, TContext>;
+export type UploadBundleMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useUploadBundleHook>>>>;
+export type UploadBundleMutationBody = BodyType<UploadBundleBody>;
+export type UploadBundleMutationError = ErrorType<unknown>;
+/**
+ * @summary Upload an application bundle file
+ */
+export declare const useUploadBundle: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUploadBundleHook>>>, TError, {
+        key: string;
+        data: BodyType<UploadBundleBody>;
+    }, TContext>;
+}) => import('@tanstack/react-query').UseMutationResult<void, TError, {
+    key: string;
+    data: BodyType<UploadBundleBody>;
+}, TContext>;
+/**
+ * @summary List apps
+ */
+export declare const useGetAllAppsHook: () => (signal?: AbortSignal) => Promise<GetAllApps200>;
+export declare const getGetAllAppsQueryKey: () => readonly ["/api/apps"];
+export declare const useGetAllAppsQueryOptions: <TData = GetAllApps200, TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllAppsHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllAppsHook>>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAllAppsQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useGetAllAppsHook>>>>;
+export type GetAllAppsQueryError = ErrorType<void>;
+/**
+ * @summary List apps
+ */
+export declare const useGetAllApps: <TData = GetAllApps200, TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllAppsHook>>>, TError, TData>>;
+}) => UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Create or update App
+ */
+export declare const useCreateOrUpdateAppHook: () => (appDto: BodyType<AppDto>) => Promise<AppDto>;
+export declare const useCreateOrUpdateAppMutationOptions: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateOrUpdateAppHook>>>, TError, {
+        data: BodyType<AppDto>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateOrUpdateAppHook>>>, TError, {
+    data: BodyType<AppDto>;
+}, TContext>;
+export type CreateOrUpdateAppMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useCreateOrUpdateAppHook>>>>;
+export type CreateOrUpdateAppMutationBody = BodyType<AppDto>;
+export type CreateOrUpdateAppMutationError = ErrorType<void>;
+/**
+ * @summary Create or update App
+ */
+export declare const useCreateOrUpdateApp: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateOrUpdateAppHook>>>, TError, {
+        data: BodyType<AppDto>;
+    }, TContext>;
+}) => import('@tanstack/react-query').UseMutationResult<AppDto, TError, {
+    data: BodyType<AppDto>;
+}, TContext>;
+/**
+ * @summary Get app by key
+ */
+export declare const useGetAppByKeyHook: () => (key: string, signal?: AbortSignal) => Promise<AppDto>;
+export declare const getGetAppByKeyQueryKey: (key: string) => readonly [`/api/apps/key/${string}`];
+export declare const useGetAppByKeyQueryOptions: <TData = AppDto, TError = import('../../use-client').HttpError>(key: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAppByKeyHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAppByKeyHook>>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAppByKeyQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useGetAppByKeyHook>>>>;
+export type GetAppByKeyQueryError = ErrorType<void>;
+/**
+ * @summary Get app by key
+ */
+export declare const useGetAppByKey: <TData = AppDto, TError = import('../../use-client').HttpError>(key: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAppByKeyHook>>>, TError, TData>>;
+}) => UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Delete app by key
+ */
+export declare const useDeleteAppByKeyHook: () => (key: string) => Promise<void>;
+export declare const useDeleteAppByKeyMutationOptions: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteAppByKeyHook>>>, TError, {
+        key: string;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteAppByKeyHook>>>, TError, {
+    key: string;
+}, TContext>;
+export type DeleteAppByKeyMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useDeleteAppByKeyHook>>>>;
+export type DeleteAppByKeyMutationError = ErrorType<unknown>;
+/**
+ * @summary Delete app by key
+ */
+export declare const useDeleteAppByKey: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteAppByKeyHook>>>, TError, {
+        key: string;
+    }, TContext>;
+}) => import('@tanstack/react-query').UseMutationResult<void, TError, {
+    key: string;
+}, TContext>;
+export {};

package/dev-portal/lib/api/roma/api/category-controller/category-controller.d.ts

@@ -0,0 +1,93 @@
+import { QueryKey, UseMutationOptions, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { CategoryDto, GetAllCategories200 } from '../../model';
+import { ErrorType, BodyType } from '../../use-client';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+/**
+ * @summary List categories
+ */
+export declare const useGetAllCategoriesHook: () => (signal?: AbortSignal) => Promise<GetAllCategories200>;
+export declare const getGetAllCategoriesQueryKey: () => readonly ["/api/apps/categories"];
+export declare const useGetAllCategoriesQueryOptions: <TData = GetAllCategories200, TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllCategoriesHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllCategoriesHook>>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAllCategoriesQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useGetAllCategoriesHook>>>>;
+export type GetAllCategoriesQueryError = ErrorType<void>;
+/**
+ * @summary List categories
+ */
+export declare const useGetAllCategories: <TData = GetAllCategories200, TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllCategoriesHook>>>, TError, TData>>;
+}) => UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Create or update category
+ */
+export declare const useCreateOrUpdateCategoryHook: () => (categoryDto: BodyType<CategoryDto>) => Promise<CategoryDto>;
+export declare const useCreateOrUpdateCategoryMutationOptions: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateOrUpdateCategoryHook>>>, TError, {
+        data: BodyType<CategoryDto>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateOrUpdateCategoryHook>>>, TError, {
+    data: BodyType<CategoryDto>;
+}, TContext>;
+export type CreateOrUpdateCategoryMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useCreateOrUpdateCategoryHook>>>>;
+export type CreateOrUpdateCategoryMutationBody = BodyType<CategoryDto>;
+export type CreateOrUpdateCategoryMutationError = ErrorType<void>;
+/**
+ * @summary Create or update category
+ */
+export declare const useCreateOrUpdateCategory: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateOrUpdateCategoryHook>>>, TError, {
+        data: BodyType<CategoryDto>;
+    }, TContext>;
+}) => import('@tanstack/react-query').UseMutationResult<CategoryDto, TError, {
+    data: BodyType<CategoryDto>;
+}, TContext>;
+/**
+ * @summary Get category by id
+ */
+export declare const useGetCategoryByIdHook: () => (id: string, signal?: AbortSignal) => Promise<CategoryDto>;
+export declare const getGetCategoryByIdQueryKey: (id: string) => readonly [`/api/apps/categories/id/${string}`];
+export declare const useGetCategoryByIdQueryOptions: <TData = CategoryDto, TError = import('../../use-client').HttpError>(id: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetCategoryByIdHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetCategoryByIdHook>>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetCategoryByIdQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useGetCategoryByIdHook>>>>;
+export type GetCategoryByIdQueryError = ErrorType<void>;
+/**
+ * @summary Get category by id
+ */
+export declare const useGetCategoryById: <TData = CategoryDto, TError = import('../../use-client').HttpError>(id: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetCategoryByIdHook>>>, TError, TData>>;
+}) => UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Delete category by id
+ */
+export declare const useDeleteCategoryByIdHook: () => (id: string) => Promise<void>;
+export declare const useDeleteCategoryByIdMutationOptions: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteCategoryByIdHook>>>, TError, {
+        id: string;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteCategoryByIdHook>>>, TError, {
+    id: string;
+}, TContext>;
+export type DeleteCategoryByIdMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useDeleteCategoryByIdHook>>>>;
+export type DeleteCategoryByIdMutationError = ErrorType<unknown>;
+/**
+ * @summary Delete category by id
+ */
+export declare const useDeleteCategoryById: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteCategoryByIdHook>>>, TError, {
+        id: string;
+    }, TContext>;
+}) => import('@tanstack/react-query').UseMutationResult<void, TError, {
+    id: string;
+}, TContext>;
+export {};

package/dev-portal/lib/api/roma/api/environment-controller/environment-controller.d.ts

@@ -0,0 +1,26 @@
+import { QueryKey, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { EnvironmentDto } from '../../model';
+import { ErrorType } from '../../use-client';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+/**
+ * @summary Get current environment
+ */
+export declare const useGetCurrentEnvironmentHook: () => (signal?: AbortSignal) => Promise<EnvironmentDto>;
+export declare const getGetCurrentEnvironmentQueryKey: () => readonly ["/_discovery/environments/current"];
+export declare const useGetCurrentEnvironmentQueryOptions: <TData = EnvironmentDto, TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetCurrentEnvironmentHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetCurrentEnvironmentHook>>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetCurrentEnvironmentQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useGetCurrentEnvironmentHook>>>>;
+export type GetCurrentEnvironmentQueryError = ErrorType<void>;
+/**
+ * @summary Get current environment
+ */
+export declare const useGetCurrentEnvironment: <TData = EnvironmentDto, TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetCurrentEnvironmentHook>>>, TError, TData>>;
+}) => UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};

package/dev-portal/lib/api/roma/api/feedback-controller/feedback-controller.d.ts

@@ -0,0 +1,50 @@
+import { QueryKey, UseMutationOptions, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { FeedbackDto, FeedbackPage, FeedbackResponseDto, ListFeedbacksByCurrentUserParams } from '../../model';
+import { ErrorType, BodyType } from '../../use-client';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+/**
+ * @summary Create feedback
+ */
+export declare const useCreateFeedbackHook: () => (feedbackDto: BodyType<FeedbackDto>) => Promise<FeedbackResponseDto>;
+export declare const useCreateFeedbackMutationOptions: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateFeedbackHook>>>, TError, {
+        data: BodyType<FeedbackDto>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateFeedbackHook>>>, TError, {
+    data: BodyType<FeedbackDto>;
+}, TContext>;
+export type CreateFeedbackMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useCreateFeedbackHook>>>>;
+export type CreateFeedbackMutationBody = BodyType<FeedbackDto>;
+export type CreateFeedbackMutationError = ErrorType<void>;
+/**
+ * @summary Create feedback
+ */
+export declare const useCreateFeedback: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useCreateFeedbackHook>>>, TError, {
+        data: BodyType<FeedbackDto>;
+    }, TContext>;
+}) => import('@tanstack/react-query').UseMutationResult<FeedbackResponseDto, TError, {
+    data: BodyType<FeedbackDto>;
+}, TContext>;
+/**
+ * @summary List feedbacks submitted by the current user
+ */
+export declare const useListFeedbacksByCurrentUserHook: () => (params?: ListFeedbacksByCurrentUserParams, signal?: AbortSignal) => Promise<FeedbackPage>;
+export declare const getListFeedbacksByCurrentUserQueryKey: (params?: ListFeedbacksByCurrentUserParams) => readonly ["/api/feedbacks/mine", ...ListFeedbacksByCurrentUserParams[]];
+export declare const useListFeedbacksByCurrentUserQueryOptions: <TData = FeedbackPage, TError = import('../../use-client').HttpError>(params?: ListFeedbacksByCurrentUserParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListFeedbacksByCurrentUserHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListFeedbacksByCurrentUserHook>>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type ListFeedbacksByCurrentUserQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useListFeedbacksByCurrentUserHook>>>>;
+export type ListFeedbacksByCurrentUserQueryError = ErrorType<void>;
+/**
+ * @summary List feedbacks submitted by the current user
+ */
+export declare const useListFeedbacksByCurrentUser: <TData = FeedbackPage, TError = import('../../use-client').HttpError>(params?: ListFeedbacksByCurrentUserParams, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useListFeedbacksByCurrentUserHook>>>, TError, TData>>;
+}) => UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};

package/dev-portal/lib/api/roma/api/roma-configuration-controller/roma-configuration-controller.d.ts

@@ -0,0 +1,161 @@
+import { QueryKey, UseMutationOptions, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { RomaConfigurationDto, SettingDto } from '../../model';
+import { ErrorType, BodyType } from '../../use-client';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+/**
+ * @summary Get roma configuration by id
+ */
+export declare const useGetRomaConfigurationByIdHook: () => (id: string, signal?: AbortSignal) => Promise<RomaConfigurationDto>;
+export declare const getGetRomaConfigurationByIdQueryKey: (id: string) => readonly [`/api/configurations/id/${string}`];
+export declare const useGetRomaConfigurationByIdQueryOptions: <TData = RomaConfigurationDto, TError = import('../../use-client').HttpError>(id: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetRomaConfigurationByIdHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetRomaConfigurationByIdHook>>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetRomaConfigurationByIdQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useGetRomaConfigurationByIdHook>>>>;
+export type GetRomaConfigurationByIdQueryError = ErrorType<void>;
+/**
+ * @summary Get roma configuration by id
+ */
+export declare const useGetRomaConfigurationById: <TData = RomaConfigurationDto, TError = import('../../use-client').HttpError>(id: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetRomaConfigurationByIdHook>>>, TError, TData>>;
+}) => UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Update a roma configuration
+ */
+export declare const useUpdateRomaConfigurationHook: () => (id: string, romaConfigurationDto: BodyType<RomaConfigurationDto>) => Promise<RomaConfigurationDto>;
+export declare const useUpdateRomaConfigurationMutationOptions: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdateRomaConfigurationHook>>>, TError, {
+        id: string;
+        data: BodyType<RomaConfigurationDto>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdateRomaConfigurationHook>>>, TError, {
+    id: string;
+    data: BodyType<RomaConfigurationDto>;
+}, TContext>;
+export type UpdateRomaConfigurationMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useUpdateRomaConfigurationHook>>>>;
+export type UpdateRomaConfigurationMutationBody = BodyType<RomaConfigurationDto>;
+export type UpdateRomaConfigurationMutationError = ErrorType<void>;
+/**
+ * @summary Update a roma configuration
+ */
+export declare const useUpdateRomaConfiguration: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useUpdateRomaConfigurationHook>>>, TError, {
+        id: string;
+        data: BodyType<RomaConfigurationDto>;
+    }, TContext>;
+}) => import('@tanstack/react-query').UseMutationResult<RomaConfigurationDto, TError, {
+    id: string;
+    data: BodyType<RomaConfigurationDto>;
+}, TContext>;
+/**
+ * @summary Delete a roma configuration by id
+ */
+export declare const useDeleteRomaConfigurationHook: () => (id: string) => Promise<SettingDto>;
+export declare const useDeleteRomaConfigurationMutationOptions: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteRomaConfigurationHook>>>, TError, {
+        id: string;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteRomaConfigurationHook>>>, TError, {
+    id: string;
+}, TContext>;
+export type DeleteRomaConfigurationMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useDeleteRomaConfigurationHook>>>>;
+export type DeleteRomaConfigurationMutationError = ErrorType<void>;
+/**
+ * @summary Delete a roma configuration by id
+ */
+export declare const useDeleteRomaConfiguration: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useDeleteRomaConfigurationHook>>>, TError, {
+        id: string;
+    }, TContext>;
+}) => import('@tanstack/react-query').UseMutationResult<SettingDto, TError, {
+    id: string;
+}, TContext>;
+/**
+ * @summary Get all roma configurations
+ */
+export declare const useGetAllRomaConfigurationHook: () => (signal?: AbortSignal) => Promise<RomaConfigurationDto[]>;
+export declare const getGetAllRomaConfigurationQueryKey: () => readonly ["/api/configurations"];
+export declare const useGetAllRomaConfigurationQueryOptions: <TData = RomaConfigurationDto[], TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationHook>>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAllRomaConfigurationQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationHook>>>>;
+export type GetAllRomaConfigurationQueryError = ErrorType<void>;
+/**
+ * @summary Get all roma configurations
+ */
+export declare const useGetAllRomaConfiguration: <TData = RomaConfigurationDto[], TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationHook>>>, TError, TData>>;
+}) => UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Create a new roma configuration
+ */
+export declare const useAddRomaConfigurationHook: () => (romaConfigurationDto: BodyType<RomaConfigurationDto>) => Promise<RomaConfigurationDto>;
+export declare const useAddRomaConfigurationMutationOptions: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useAddRomaConfigurationHook>>>, TError, {
+        data: BodyType<RomaConfigurationDto>;
+    }, TContext>;
+}) => UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useAddRomaConfigurationHook>>>, TError, {
+    data: BodyType<RomaConfigurationDto>;
+}, TContext>;
+export type AddRomaConfigurationMutationResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useAddRomaConfigurationHook>>>>;
+export type AddRomaConfigurationMutationBody = BodyType<RomaConfigurationDto>;
+export type AddRomaConfigurationMutationError = ErrorType<void>;
+/**
+ * @summary Create a new roma configuration
+ */
+export declare const useAddRomaConfiguration: <TError = import('../../use-client').HttpError, TContext = unknown>(options?: {
+    mutation?: UseMutationOptions<Awaited<ReturnType<ReturnType<typeof useAddRomaConfigurationHook>>>, TError, {
+        data: BodyType<RomaConfigurationDto>;
+    }, TContext>;
+}) => import('@tanstack/react-query').UseMutationResult<RomaConfigurationDto, TError, {
+    data: BodyType<RomaConfigurationDto>;
+}, TContext>;
+/**
+ * @summary Get valid roma configuration types
+ */
+export declare const useGetAllRomaConfigurationTypesHook: () => (signal?: AbortSignal) => Promise<"servicebus"[]>;
+export declare const getGetAllRomaConfigurationTypesQueryKey: () => readonly ["/api/configurations/types"];
+export declare const useGetAllRomaConfigurationTypesQueryOptions: <TData = "servicebus"[], TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationTypesHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationTypesHook>>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAllRomaConfigurationTypesQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationTypesHook>>>>;
+export type GetAllRomaConfigurationTypesQueryError = ErrorType<void>;
+/**
+ * @summary Get valid roma configuration types
+ */
+export declare const useGetAllRomaConfigurationTypes: <TData = "servicebus"[], TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationTypesHook>>>, TError, TData>>;
+}) => UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+/**
+ * @summary Get all roma configurations for given type
+ */
+export declare const useGetAllRomaConfigurationByTypeHook: () => (type: string, signal?: AbortSignal) => Promise<RomaConfigurationDto[]>;
+export declare const getGetAllRomaConfigurationByTypeQueryKey: (type: string) => readonly [`/api/configurations/types/type/${string}`];
+export declare const useGetAllRomaConfigurationByTypeQueryOptions: <TData = RomaConfigurationDto[], TError = import('../../use-client').HttpError>(type: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationByTypeHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationByTypeHook>>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type GetAllRomaConfigurationByTypeQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationByTypeHook>>>>;
+export type GetAllRomaConfigurationByTypeQueryError = ErrorType<void>;
+/**
+ * @summary Get all roma configurations for given type
+ */
+export declare const useGetAllRomaConfigurationByType: <TData = RomaConfigurationDto[], TError = import('../../use-client').HttpError>(type: string, options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useGetAllRomaConfigurationByTypeHook>>>, TError, TData>>;
+}) => UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};

package/dev-portal/lib/api/roma/api/server-side-event-controller/server-side-event-controller.d.ts

@@ -0,0 +1,20 @@
+import { QueryKey, UseQueryOptions, UseQueryResult } from '@tanstack/react-query';
+import { ServerSentEventStandardEventDto } from '../../model';
+import { ErrorType } from '../../use-client';
+type AwaitedInput<T> = PromiseLike<T> | T;
+type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;
+export declare const useStreamEventsHook: () => (signal?: AbortSignal) => Promise<ServerSentEventStandardEventDto[]>;
+export declare const getStreamEventsQueryKey: () => readonly ["/eventstream/activitylog"];
+export declare const useStreamEventsQueryOptions: <TData = ServerSentEventStandardEventDto[], TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useStreamEventsHook>>>, TError, TData>>;
+}) => UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useStreamEventsHook>>>, TError, TData> & {
+    queryKey: QueryKey;
+};
+export type StreamEventsQueryResult = NonNullable<Awaited<ReturnType<ReturnType<typeof useStreamEventsHook>>>>;
+export type StreamEventsQueryError = ErrorType<unknown>;
+export declare const useStreamEvents: <TData = ServerSentEventStandardEventDto[], TError = import('../../use-client').HttpError>(options?: {
+    query?: Partial<UseQueryOptions<Awaited<ReturnType<ReturnType<typeof useStreamEventsHook>>>, TError, TData>>;
+}) => UseQueryResult<TData, TError> & {
+    queryKey: QueryKey;
+};
+export {};