@nizza/core 0.3.0-alpha.1 → 0.3.0-alpha.10

package/{src → dist}/lib/domain/index.d.ts

@@ -1,4 +1,3 @@
 export * from './AggregateRoot';
 export * from './BaseMobxStore';
-export * from './errors';
 export * from './ValueObject';

package/{src/lib/domain → dist/lib}/errors/app.d.ts

@@ -5,3 +5,6 @@ export declare class UnexpectedError extends DomainError {
 export declare class AccountInvalidError extends DomainError {
     constructor();
 }
+export declare class InvalidNizzaGlobalObjectError extends DomainError {
+    constructor(prop: string);
+}

package/{src → dist}/lib/providers/StoreProvider.d.ts

@@ -1,8 +1,7 @@
 import { FC } from 'react';
-import { BaseStore, StoreClass, StoreFactory } from '../types';
+import { AppModuleStoreList, StoreClass } from '../types';
 interface Props {
-    instances?: BaseStore[];
-    stores: (StoreClass | StoreFactory)[];
+    stores: AppModuleStoreList;
     children?: React.ReactNode;
 }
 export declare const StoreProvider: FC<Props>;

package/{src → dist}/lib/stores/NizzaStore.d.ts

@@ -1,8 +1,11 @@
 import { NizzaConfiguration, NizzaGlobalObjet } from '../types';
 export declare class NizzaStore implements NizzaGlobalObjet {
+    private _id;
     private _config;
     constructor();
     configure(config: NizzaConfiguration): void;
+    createGlobalObject(): void;
     get config(): NizzaConfiguration;
+    private validateRequiredProps;
 }
 export declare const nizza: NizzaStore;

package/{src → dist}/lib/types/api-graphql-types.d.ts

@@ -1,19 +1,19 @@
 import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
-export type Maybe<T> = T | null;
-export type InputMaybe<T> = Maybe<T>;
-export type Exact<T extends {
+export declare type Maybe<T> = T | null;
+export declare type InputMaybe<T> = Maybe<T>;
+export declare type Exact<T extends {
     [key: string]: unknown;
 }> = {
     [K in keyof T]: T[K];
 };
-export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
     [SubKey in K]?: Maybe<T[SubKey]>;
 };
-export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
     [SubKey in K]: Maybe<T[SubKey]>;
 };
 /** All built-in and custom scalars, mapped to their actual values */
-export type Scalars = {
+export declare type Scalars = {
     ID: string;
     String: string;
     Boolean: boolean;
@@ -22,7 +22,16 @@ export type Scalars = {
     DateTime: any;
     JSON: any;
 };
-export type Collection = {
+export declare type ActionSnackVideoSuccess = {
+    __typename?: 'ActionSnackVideoSuccess';
+    message: Scalars['String'];
+};
+export declare type Clip = {
+    endTime: Scalars['String'];
+    name: Scalars['String'];
+    startTime: Scalars['String'];
+};
+export declare type Collection = {
     __typename?: 'Collection';
     account?: Maybe<Scalars['String']>;
     createdat?: Maybe<Scalars['DateTime']>;
@@ -36,9 +45,9 @@ export type Collection = {
     products?: Maybe<Array<Product>>;
     status?: Maybe<Scalars['String']>;
 };
-export type CollectionResult = CollectionSuccess | ErrorGeneral;
-export type CollectionResultArray = CollectionSuccessArray | ErrorGeneral;
-export type CollectionSuccess = {
+export declare type CollectionResult = CollectionSuccess | ErrorGeneral;
+export declare type CollectionResultArray = CollectionSuccessArray | ErrorGeneral;
+export declare type CollectionSuccess = {
     __typename?: 'CollectionSuccess';
     data?: Maybe<Collection>;
     duration?: Maybe<Scalars['String']>;
@@ -46,7 +55,7 @@ export type CollectionSuccess = {
     method?: Maybe<Scalars['String']>;
     path?: Maybe<Scalars['String']>;
 };
-export type CollectionSuccessArray = {
+export declare type CollectionSuccessArray = {
     __typename?: 'CollectionSuccessArray';
     data?: Maybe<Array<Collection>>;
     duration?: Maybe<Scalars['String']>;
@@ -54,13 +63,19 @@ export type CollectionSuccessArray = {
     method?: Maybe<Scalars['String']>;
     path?: Maybe<Scalars['String']>;
 };
-export type CreateCollectionInput = {
+export declare type CreateCollectionInput = {
     account: Scalars['String'];
     description?: InputMaybe<Scalars['String']>;
     name: Scalars['String'];
     status?: InputMaybe<Status>;
 };
-export type CustomPlayer = {
+export declare type CreateSnackVideoInput = {
+    account: Scalars['String'];
+    clips: Array<Clip>;
+    idEvent: Scalars['String'];
+};
+export declare type CreateSnackVideoResult = ErrorGeneral | SnackVideoArray;
+export declare type CustomPlayer = {
     __typename?: 'CustomPlayer';
     account: Scalars['String'];
     component: Scalars['String'];
@@ -72,18 +87,18 @@ export type CustomPlayer = {
     path?: Maybe<Scalars['String']>;
     section: Scalars['String'];
 };
-export type CustomPlayerInput = {
+export declare type CustomPlayerInput = {
     account: Scalars['String'];
     data: Scalars['JSON'];
     id: Scalars['String'];
     section: Scalars['String'];
 };
-export type CustomPlayerInputAccount = {
+export declare type CustomPlayerInputAccount = {
     account: Scalars['String'];
 };
-export type CustomPlayerResult = CustomPlayerSuccess | ErrorGeneral;
-export type CustomPlayerResultArray = CustomPlayerSuccessArray | ErrorGeneral;
-export type CustomPlayerSuccess = {
+export declare type CustomPlayerResult = CustomPlayerSuccess | ErrorGeneral;
+export declare type CustomPlayerResultArray = CustomPlayerSuccessArray | ErrorGeneral;
+export declare type CustomPlayerSuccess = {
     __typename?: 'CustomPlayerSuccess';
     data?: Maybe<CustomPlayer>;
     duration?: Maybe<Scalars['String']>;
@@ -91,7 +106,7 @@ export type CustomPlayerSuccess = {
     method?: Maybe<Scalars['String']>;
     path?: Maybe<Scalars['String']>;
 };
-export type CustomPlayerSuccessArray = {
+export declare type CustomPlayerSuccessArray = {
     __typename?: 'CustomPlayerSuccessArray';
     data?: Maybe<Array<CustomPlayer>>;
     duration?: Maybe<Scalars['String']>;
@@ -99,18 +114,23 @@ export type CustomPlayerSuccessArray = {
     method?: Maybe<Scalars['String']>;
     path?: Maybe<Scalars['String']>;
 };
-export type Error = {
+export declare type Error = {
     message: Scalars['String'];
     statusCode: Scalars['String'];
     timestamp: Scalars['String'];
 };
-export type ErrorGeneral = Error & {
+export declare type ErrorGeneral = Error & {
     __typename?: 'ErrorGeneral';
     message: Scalars['String'];
     statusCode: Scalars['String'];
     timestamp: Scalars['String'];
 };
-export type ManageCollectionProductInInput = {
+export declare type FindManySnackVideoInput = {
+    account: Scalars['String'];
+    ids: Array<Scalars['String']>;
+};
+export declare type FindManySnackVideoResult = ErrorGeneral | SnackVideoArray;
+export declare type ManageCollectionProductInInput = {
     account: Scalars['String'];
     id: Scalars['String'];
     method: Methods;
@@ -120,34 +140,50 @@ export declare enum Methods {
     Add = "add",
     Remove = "remove"
 }
-export type Mutation = {
+export declare type Mutation = {
     __typename?: 'Mutation';
+    appendProductsSnackVideo: RelateEntitySnackVideo;
     createCollection: CollectionResult;
+    createSnackVideos: CreateSnackVideoResult;
     deleteAllCustomPlayer: CustomPlayerResult;
     deleteCollection: CollectionResult;
+    deleteRelationshipSnackVideo: RelateEntitySnackVideo;
     manageCollectionProduct: CollectionResult;
     updateCollection: CollectionResult;
     updateCustomPlayer: CustomPlayerResult;
+    updateProgressSnackVideo: UpdateProgressSnackVideosResult;
 };
-export type MutationCreateCollectionArgs = {
+export declare type MutationAppendProductsSnackVideoArgs = {
+    data: RelateToProductsSnackVideoInput;
+};
+export declare type MutationCreateCollectionArgs = {
     data: CreateCollectionInput;
 };
-export type MutationDeleteAllCustomPlayerArgs = {
+export declare type MutationCreateSnackVideosArgs = {
+    data: CreateSnackVideoInput;
+};
+export declare type MutationDeleteAllCustomPlayerArgs = {
     data: CustomPlayerInputAccount;
 };
-export type MutationDeleteCollectionArgs = {
+export declare type MutationDeleteCollectionArgs = {
     data: QueryInput;
 };
-export type MutationManageCollectionProductArgs = {
+export declare type MutationDeleteRelationshipSnackVideoArgs = {
+    data: SnackVideoRelationshipKeys;
+};
+export declare type MutationManageCollectionProductArgs = {
     data: ManageCollectionProductInInput;
 };
-export type MutationUpdateCollectionArgs = {
+export declare type MutationUpdateCollectionArgs = {
     data: UpdateCollectionInput;
 };
-export type MutationUpdateCustomPlayerArgs = {
+export declare type MutationUpdateCustomPlayerArgs = {
     data: CustomPlayerInput;
 };
-export type Product = {
+export declare type MutationUpdateProgressSnackVideoArgs = {
+    data: UpdateProgressSnackVideosInput;
+};
+export declare type Product = {
     __typename?: 'Product';
     account: Scalars['String'];
     createdat?: Maybe<Scalars['String']>;
@@ -159,47 +195,177 @@ export type Product = {
     status?: Maybe<Status>;
     title: Scalars['String'];
 };
-export type Query = {
+export declare type Query = {
     __typename?: 'Query';
     findCollection: CollectionResult;
+    findManySnackVideos: FindManySnackVideoResult;
     getAllCollection: CollectionResultArray;
     getAllCustomPlayer: CustomPlayerResultArray;
+    getAllSnackVideos: SnackVideoGetAll;
+    getRelationshipSnackVideos: RelationshipSnackVideoArrayResponse;
     searchCollection: CollectionResultArray;
+    searchSnackVideos: SnackVideoGetAll;
+};
+export declare type QueryFindCollectionArgs = {
+    data: QueryInput;
+};
+export declare type QueryFindManySnackVideosArgs = {
+    data: FindManySnackVideoInput;
 };
-export type QueryFindCollectionArgs = {
+export declare type QueryGetAllCollectionArgs = {
     data: QueryInput;
 };
-export type QueryGetAllCollectionArgs = {
+export declare type QueryGetAllCustomPlayerArgs = {
     data: QueryInput;
 };
-export type QueryGetAllCustomPlayerArgs = {
+export declare type QueryGetAllSnackVideosArgs = {
     data: QueryInput;
 };
-export type QuerySearchCollectionArgs = {
+export declare type QueryGetRelationshipSnackVideosArgs = {
+    data: SnackVideoRelationshipInput;
+};
+export declare type QuerySearchCollectionArgs = {
     data: QueryInput;
 };
-export type QueryInput = {
+export declare type QuerySearchSnackVideosArgs = {
+    data: SearchInput;
+};
+export declare type QueryInput = {
     account: Scalars['String'];
+    cursor?: InputMaybe<Scalars['JSON']>;
     id?: InputMaybe<Scalars['String']>;
     limit?: InputMaybe<Scalars['Float']>;
     page?: InputMaybe<Scalars['Float']>;
     search?: InputMaybe<Scalars['String']>;
 };
+export declare type RelateEntitySnackVideo = ActionSnackVideoSuccess | ErrorGeneral;
+export declare type RelateToProductsSnackVideoInput = {
+    account: Scalars['String'];
+    name: Scalars['String'];
+    productsId: Array<Scalars['String']>;
+    shortId: Scalars['String'];
+    url: Scalars['String'];
+};
+export declare type RelationshipSnackVideo = {
+    __typename?: 'RelationshipSnackVideo';
+    attributeId: Scalars['String'];
+    created: Scalars['String'];
+    entity: Scalars['String'];
+    modified: Scalars['String'];
+    name: Scalars['String'];
+    shortId: Scalars['String'];
+    sourceEntity: Scalars['String'];
+    url: Scalars['String'];
+};
+export declare type RelationshipSnackVideoArray = {
+    __typename?: 'RelationshipSnackVideoArray';
+    data?: Maybe<Array<RelationshipSnackVideo>>;
+    duration?: Maybe<Scalars['String']>;
+    isArray?: Maybe<Scalars['Boolean']>;
+    method?: Maybe<Scalars['String']>;
+    path?: Maybe<Scalars['String']>;
+};
+export declare type RelationshipSnackVideoArrayResponse = ErrorGeneral | RelationshipSnackVideoArray;
+export declare type SearchInput = {
+    account: Scalars['String'];
+    cursor?: InputMaybe<Scalars['JSON']>;
+    id?: InputMaybe<Scalars['String']>;
+    limit?: InputMaybe<Scalars['Float']>;
+    page?: InputMaybe<Scalars['Float']>;
+    search: Scalars['String'];
+};
+export declare type SnackVideo = {
+    __typename?: 'SnackVideo';
+    duration: Scalars['Float'];
+    eventId: Scalars['String'];
+    eventName: Scalars['String'];
+    id: Scalars['String'];
+    name: Scalars['String'];
+    thumbnailUrl: Scalars['String'];
+    uploadProgress: Scalars['Float'];
+    url: Scalars['String'];
+};
+export declare type SnackVideoArray = {
+    __typename?: 'SnackVideoArray';
+    data?: Maybe<Array<SnackVideo>>;
+    duration?: Maybe<Scalars['String']>;
+    isArray?: Maybe<Scalars['Boolean']>;
+    method?: Maybe<Scalars['String']>;
+    path?: Maybe<Scalars['String']>;
+};
+export declare type SnackVideoCreatedArray = {
+    __typename?: 'SnackVideoCreatedArray';
+    data?: Maybe<SnackVideoCreatedWithCursor>;
+    duration?: Maybe<Scalars['String']>;
+    isArray?: Maybe<Scalars['Boolean']>;
+    method?: Maybe<Scalars['String']>;
+    path?: Maybe<Scalars['String']>;
+};
+export declare type SnackVideoCreatedWithCursor = {
+    __typename?: 'SnackVideoCreatedWithCursor';
+    cursor?: Maybe<Scalars['JSON']>;
+    snackVideos?: Maybe<Array<SnackVideosCreated>>;
+};
+export declare type SnackVideoGetAll = ErrorGeneral | SnackVideoCreatedArray;
+export declare type SnackVideoRelationshipInput = {
+    account: Scalars['String'];
+    shortId: Scalars['String'];
+};
+export declare type SnackVideoRelationshipKeys = {
+    account: Scalars['String'];
+    attributeId: Scalars['String'];
+    shortId: Scalars['String'];
+    sourceEntity: Scalars['String'];
+};
+export declare type SnackVideosCreated = {
+    __typename?: 'SnackVideosCreated';
+    created: Scalars['String'];
+    duration: Scalars['Float'];
+    entity: Scalars['String'];
+    eventId: Scalars['String'];
+    eventName: Scalars['String'];
+    id: Scalars['String'];
+    modified: Scalars['String'];
+    name: Scalars['String'];
+    thumbnailUrl: Scalars['String'];
+    uploadProgress: Scalars['Float'];
+    url: Scalars['String'];
+};
 export declare enum Status {
     Active = "active",
     Inactive = "inactive"
 }
-export type UpdateCollectionInput = {
+export declare type UpdateCollectionInput = {
     account: Scalars['String'];
     description?: InputMaybe<Scalars['String']>;
     id: Scalars['String'];
     name?: InputMaybe<Scalars['String']>;
     status?: InputMaybe<Status>;
 };
-export type DeleteAllCustomizationMutationVariables = Exact<{
+export declare type UpdateProgressSnackVideos = {
+    __typename?: 'UpdateProgressSnackVideos';
+    account: Scalars['String'];
+    id: Scalars['String'];
+    progress: Scalars['Float'];
+};
+export declare type UpdateProgressSnackVideosData = {
+    __typename?: 'UpdateProgressSnackVideosData';
+    data?: Maybe<UpdateProgressSnackVideos>;
+    duration?: Maybe<Scalars['String']>;
+    isArray?: Maybe<Scalars['Boolean']>;
+    method?: Maybe<Scalars['String']>;
+    path?: Maybe<Scalars['String']>;
+};
+export declare type UpdateProgressSnackVideosInput = {
+    account: Scalars['String'];
+    id: Scalars['String'];
+    progress: Scalars['Float'];
+};
+export declare type UpdateProgressSnackVideosResult = ErrorGeneral | UpdateProgressSnackVideosData;
+export declare type DeleteAllCustomizationMutationVariables = Exact<{
     data: CustomPlayerInputAccount;
 }>;
-export type DeleteAllCustomizationMutation = {
+export declare type DeleteAllCustomizationMutation = {
     __typename?: 'Mutation';
     deleteAllCustomPlayer: {
         __typename: 'CustomPlayerSuccess';
@@ -210,10 +376,10 @@ export type DeleteAllCustomizationMutation = {
         timestamp: string;
     };
 };
-export type GetAllCustomizationQueryVariables = Exact<{
+export declare type GetAllCustomizationQueryVariables = Exact<{
     data: QueryInput;
 }>;
-export type GetAllCustomizationQuery = {
+export declare type GetAllCustomizationQuery = {
     __typename?: 'Query';
     getAllCustomPlayer: {
         __typename: 'CustomPlayerSuccessArray';
@@ -231,10 +397,10 @@ export type GetAllCustomizationQuery = {
         timestamp: string;
     };
 };
-export type UpdateCustomizationMutationVariables = Exact<{
+export declare type UpdateCustomizationMutationVariables = Exact<{
     data: CustomPlayerInput;
 }>;
-export type UpdateCustomizationMutation = {
+export declare type UpdateCustomizationMutation = {
     __typename?: 'Mutation';
     updateCustomPlayer: {
         __typename: 'CustomPlayerSuccess';
@@ -245,10 +411,10 @@ export type UpdateCustomizationMutation = {
         timestamp: string;
     };
 };
-export type AddCollectionMutationVariables = Exact<{
+export declare type AddCollectionMutationVariables = Exact<{
     data: CreateCollectionInput;
 }>;
-export type AddCollectionMutation = {
+export declare type AddCollectionMutation = {
     __typename?: 'Mutation';
     createCollection: {
         __typename: 'CollectionSuccess';
@@ -263,10 +429,10 @@ export type AddCollectionMutation = {
         timestamp: string;
     };
 };
-export type DeleteCollectionMutationVariables = Exact<{
+export declare type DeleteCollectionMutationVariables = Exact<{
     data: QueryInput;
 }>;
-export type DeleteCollectionMutation = {
+export declare type DeleteCollectionMutation = {
     __typename?: 'Mutation';
     deleteCollection: {
         __typename: 'CollectionSuccess';
@@ -277,10 +443,10 @@ export type DeleteCollectionMutation = {
         timestamp: string;
     };
 };
-export type FindCollectionQueryVariables = Exact<{
+export declare type FindCollectionQueryVariables = Exact<{
     data: QueryInput;
 }>;
-export type FindCollectionQuery = {
+export declare type FindCollectionQuery = {
     __typename?: 'Query';
     findCollection: {
         __typename: 'CollectionSuccess';
@@ -312,10 +478,10 @@ export type FindCollectionQuery = {
         timestamp: string;
     };
 };
-export type GetAllCollectionsQueryVariables = Exact<{
+export declare type GetAllCollectionsQueryVariables = Exact<{
     data: QueryInput;
 }>;
-export type GetAllCollectionsQuery = {
+export declare type GetAllCollectionsQuery = {
     __typename?: 'Query';
     getAllCollection: {
         __typename: 'CollectionSuccessArray';
@@ -347,10 +513,10 @@ export type GetAllCollectionsQuery = {
         timestamp: string;
     };
 };
-export type ManageCollectionProductMutationVariables = Exact<{
+export declare type ManageCollectionProductMutationVariables = Exact<{
     data: ManageCollectionProductInInput;
 }>;
-export type ManageCollectionProductMutation = {
+export declare type ManageCollectionProductMutation = {
     __typename?: 'Mutation';
     manageCollectionProduct: {
         __typename: 'CollectionSuccess';
@@ -361,10 +527,10 @@ export type ManageCollectionProductMutation = {
         timestamp: string;
     };
 };
-export type SearchCollectionsQueryVariables = Exact<{
+export declare type SearchCollectionsQueryVariables = Exact<{
     data: QueryInput;
 }>;
-export type SearchCollectionsQuery = {
+export declare type SearchCollectionsQuery = {
     __typename?: 'Query';
     searchCollection: {
         __typename: 'CollectionSuccessArray';
@@ -396,10 +562,10 @@ export type SearchCollectionsQuery = {
         timestamp: string;
     };
 };
-export type UpdateCollectionMutationVariables = Exact<{
+export declare type UpdateCollectionMutationVariables = Exact<{
     data: UpdateCollectionInput;
 }>;
-export type UpdateCollectionMutation = {
+export declare type UpdateCollectionMutation = {
     __typename?: 'Mutation';
     updateCollection: {
         __typename: 'CollectionSuccess';
@@ -410,6 +576,37 @@ export type UpdateCollectionMutation = {
         timestamp: string;
     };
 };
+export declare type GetAllSnackVideosQueryVariables = Exact<{
+    data: QueryInput;
+}>;
+export declare type GetAllSnackVideosQuery = {
+    __typename?: 'Query';
+    getAllSnackVideos: {
+        __typename: 'ErrorGeneral';
+        message: string;
+        statusCode: string;
+        timestamp: string;
+    } | {
+        __typename: 'SnackVideoCreatedArray';
+        data?: {
+            __typename?: 'SnackVideoCreatedWithCursor';
+            cursor?: any | null;
+            snackVideos?: Array<{
+                __typename?: 'SnackVideosCreated';
+                id: string;
+                name: string;
+                url: string;
+                thumbnailUrl: string;
+                uploadProgress: number;
+                duration: number;
+                eventId: string;
+                eventName: string;
+                created: string;
+                modified: string;
+            }> | null;
+        } | null;
+    };
+};
 export declare const DeleteAllCustomizationDocument: DocumentNode<DeleteAllCustomizationMutation, Exact<{
     data: CustomPlayerInputAccount;
 }>>;
@@ -440,3 +637,6 @@ export declare const SearchCollectionsDocument: DocumentNode<SearchCollectionsQu
 export declare const UpdateCollectionDocument: DocumentNode<UpdateCollectionMutation, Exact<{
     data: UpdateCollectionInput;
 }>>;
+export declare const GetAllSnackVideosDocument: DocumentNode<GetAllSnackVideosQuery, Exact<{
+    data: QueryInput;
+}>>;

package/dist/lib/types/app-module.d.ts

@@ -0,0 +1,17 @@
+import { RouteProps } from 'react-router-dom';
+import { StoreClass } from './mobx-store';
+declare type Store<T extends {
+    new (): InstanceType<T>;
+}> = Readonly<{
+    readonly class: T;
+    readonly value: InstanceType<T>;
+}>;
+export declare type AppModuleStoreList = Store<any>[];
+export interface AppModule {
+    key: string;
+    label: string;
+    route?: RouteProps;
+    stores?: AppModuleStoreList;
+}
+export declare function createStore<T extends StoreClass>(store: T): Store<T>;
+export {};

package/dist/lib/types/mobx-store.d.ts

@@ -0,0 +1,3 @@
+import { Constructor } from './utils';
+export declare type StoreClass<T = any> = Constructor<T>;
+export declare type StoreFactory<T = any> = (...args: any[]) => T;

package/dist/lib/types/products/product.d.ts

@@ -0,0 +1,16 @@
+import { NizzaProduct } from './base';
+export declare type NizzaGetProductHandler = (input: NizzaGetProductHandlerInput) => Promise<NizzaProduct>;
+export declare type NizzaGetProductListHandler = (input: NizzaGetProductListHandlerInput) => Promise<NizzaProduct[]>;
+declare type NizzaGetProductHandlerInput = {
+    productId: string;
+};
+declare type NizzaGetProductListHandlerInput = {
+    search?: string;
+    page?: number;
+    limit?: number;
+};
+export interface NizzaProductRepository {
+    getProduct: NizzaGetProductHandler;
+    getProductList: NizzaGetProductListHandler;
+}
+export {};

package/{src → dist}/lib/types/utils.d.ts

@@ -1,7 +1,5 @@
 import environment from '../../environments/environment';
-export type Constructor<T = any> = new (...args: any[]) => T;
-export declare abstract class BaseStore {
-}
+export declare type Constructor<T = any> = new (...args: any[]) => T;
 export interface ApiV1Response<T = any> {
     success: boolean;
     message: string;
@@ -14,9 +12,12 @@ export interface ApiV2Response<T = any> {
     duration: string;
     method: 'GET' | 'POST' | 'PUT' | 'DELETE';
 }
-export type Primitive = string | boolean | number;
+export declare type Primitive = string | boolean | number;
 export interface ApiCall extends RequestInit {
     url: RequestInfo;
     raw?: boolean;
 }
-export type Environment<T> = typeof environment & T;
+export declare type Environment<T> = typeof environment & T;
+export declare type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];

package/{src → dist}/lib/utils/Result.d.ts

@@ -9,7 +9,7 @@ export declare class Result<V, E = string> {
     static fail<F = string>(error: F): Result<never, F>;
     static combine(results: Result<any, any>[]): Result<any, any>;
 }
-export type Either<L, A> = Err<L, A> | Ok<L, A>;
+export declare type Either<L, A> = Err<L, A> | Ok<L, A>;
 export declare class Err<L, A> {
     readonly value: L;
     constructor(value: L);

package/{src → dist}/lib/utils/customStorage/utils.d.ts

@@ -1,4 +1,4 @@
-type StorageType = 'localStorage' | 'sessionStorage';
+declare type StorageType = 'localStorage' | 'sessionStorage';
 export declare function isStorageAvailable(type: StorageType): boolean;
 export declare function setProperty(obj: unknown, name: string, value: unknown): void;
 export {};

package/dist/lib/utils/fingerprint.d.ts

@@ -0,0 +1 @@
+export declare const getFingerprint: () => string;

package/{src → dist}/lib/utils/helpers.d.ts

@@ -1,3 +1,3 @@
 import { Primitive } from '../types';
-export declare function shortId(length?: number): string;
+export declare const shortId: (length?: number) => string;
 export declare const searchParams: (params: Record<string, Primitive>) => string;