@sarafapp/iron_core 1.0.17

package/dist/src/baseTable/TableHeaderSchema.d.ts

@@ -0,0 +1,27 @@
+import { CellType, HeaderType, LoadingStatus, SortOrder, TableHeaderAlign } from '../constants';
+import { Accessible } from '../accessHandling';
+export interface TableHeaderSchema<Model> extends Accessible {
+    path?: keyof Model;
+    title: string;
+    getProps?: (row: Model) => Record<string, unknown>;
+    key: keyof Model;
+    cellType?: CellType;
+    align?: TableHeaderAlign;
+    headerType?: HeaderType;
+    colspan?: number;
+    width?: string | number;
+    ellipsis?: boolean;
+    maxWidth?: number;
+    minWidth?: number;
+    resizable?: boolean;
+    sortOrder?: SortOrder;
+    sorter?: boolean;
+}
+export interface TableRenderingData<Model> {
+    totalItems: number;
+    currentPage: number;
+    rows: Model[];
+    loadingStatus: Set<LoadingStatus>;
+    currentPageItems: Model[];
+}
+export declare function generateHeader<Model>(header: TableHeaderSchema<Model>): TableHeaderSchema<Model>;

package/dist/src/baseTable/TableLoader.d.ts

@@ -0,0 +1,3 @@
+export interface TableLoader<Model> {
+    loadRows(): Promise<Model>;
+}

package/dist/src/baseTable/TablePaginate.d.ts

@@ -0,0 +1,3 @@
+export interface TablePaginate {
+    handlePagination(nextPage: number, pageSize: number): Promise<void>;
+}

package/dist/src/baseTable/TableService.d.ts

@@ -0,0 +1,9 @@
+import { SortDetail } from '../sort';
+import { FetchListResponse } from '../repository/model';
+import { TableRenderingData } from './TableHeaderSchema';
+export interface TableService<Model> {
+    fetchRows(): Promise<FetchListResponse<Model>>;
+    paginate(nextPage: number, pageSize: number): Promise<FetchListResponse<Model>>;
+    sort(sortDetail: SortDetail<Model>): Promise<FetchListResponse<Model>>;
+    getData(): TableRenderingData<Model>;
+}

package/dist/src/baseTable/TableSort.d.ts

@@ -0,0 +1,4 @@
+import { SortDetail } from '../sort';
+export interface TableSort<Model> {
+    handleSort(sortDetail: SortDetail<Model>): Promise<void>;
+}

package/dist/src/baseTable/TableSummarySchema.d.ts

@@ -0,0 +1,9 @@
+import { TableHeaderAlign } from '../constants';
+export interface TableSummaryItem {
+    data: string | number;
+    align: TableHeaderAlign;
+}
+export interface TableSummarySchema {
+    summaryTitle: string;
+    summaryItems: TableSummaryItem[];
+}

package/dist/src/baseTable/index.d.ts

@@ -0,0 +1,15 @@
+export type { TableAction } from './TableAction';
+export type { TableService } from './TableService';
+export type { Destroy } from './OnDestory';
+export type { RowActionSource } from './RowActionSource';
+export type { TableLoader } from './TableLoader';
+export type { TablePaginate } from './TablePaginate';
+export { TABLE_ACTION_COLUMN, TABLE_COLUMN_DEFAULT_VALUES, TABLE_COLUMN_DEFAULT_COLSPAN, TABLE_COLUMN_DEFAULT_WIDTH, } from './Constants';
+export { BaseTable } from './BaseTable';
+export { SelectableTable } from './SelectableTable';
+export { type TableHeaderSchema, type TableRenderingData, generateHeader, } from './TableHeaderSchema';
+export { Column } from './moduleConnection/Column';
+export { Table } from './moduleConnection/Table';
+export { Action } from './moduleConnection/Action';
+export { TableDestroy } from './moduleConnection/TableDestroy';
+export { TableRowClick } from './moduleConnection/TableRowClick';

package/dist/src/baseTable/moduleConnection/Action.d.ts

@@ -0,0 +1,3 @@
+import { ActionDecorator } from '../TableAction';
+import { BaseModel } from '../../BaseModel';
+export declare function Action<Model extends BaseModel>(actionDetail: Omit<ActionDecorator<Model>, 'handler'>): (target: BaseModel, _propertyKey: string, propertyDescriptor: PropertyDescriptor) => void;

package/dist/src/baseTable/moduleConnection/Column.d.ts

@@ -0,0 +1,3 @@
+import { TableHeaderSchema } from '../TableHeaderSchema';
+import { BaseModel } from '../../BaseModel';
+export declare function Column<Model extends BaseModel>(header: TableHeaderSchema<Model>): (target: BaseModel, propertyKey: string) => void;

package/dist/src/baseTable/moduleConnection/Table.d.ts

@@ -0,0 +1,4 @@
+import { BaseTable } from '../../baseTable';
+import { BaseModel } from '../../BaseModel';
+import { SelectableTable } from '../SelectableTable';
+export declare function Table<Model extends BaseModel>(table: typeof BaseTable<Model> | typeof SelectableTable<Model>): (constructor: Function) => void;

package/dist/src/baseTable/moduleConnection/TableDestroy.d.ts

@@ -0,0 +1,2 @@
+import { BaseModel } from '../../BaseModel';
+export declare function TableDestroy(): (target: BaseModel, _propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/src/baseTable/moduleConnection/TableRowClick.d.ts

@@ -0,0 +1,2 @@
+import { BaseModel } from '../../BaseModel';
+export declare function TableRowClick(): (target: BaseModel, _propertyKey: string, descriptor: PropertyDescriptor) => void;

package/dist/src/composables/UseCrud.d.ts

@@ -0,0 +1,10 @@
+import { BaseModel } from '../BaseModel';
+export declare function useCrud<Entity extends BaseModel>(): {
+    entityItemsAsArray: any;
+    addOrReplaceItems: (items: Entity[]) => void;
+    removeById: (id: string | number) => any;
+    getItemById: (id: number | string) => any;
+    clearItems: () => void;
+    setTotalCount: (count: number) => void;
+    getTotalCount: any;
+};

package/dist/src/composables/UseData.d.ts

@@ -0,0 +1,14 @@
+import { BaseModel } from '../BaseModel';
+import { Nullable } from '../types';
+export declare function useData<Model extends BaseModel>(): {
+    itemsAsArray: any;
+    totalCount: any;
+    currentItem: any;
+    setTotalCount: (totalItems: number) => void;
+    addOrReplaceItems: (itemsToAdd: Model[]) => void;
+    getById: (id: number) => Nullable<Model>;
+    removeById: (id: number) => boolean;
+    clearItems: () => void;
+    setCurrentItem: (item: Nullable<Model>) => void;
+    clearCurrentItem: () => void;
+};

package/dist/src/composables/UseLoadingStatus.d.ts

@@ -0,0 +1,15 @@
+import { LoadingStatus } from '../constants';
+export declare function useLoadingStatus(): {
+    loadingStatus: any;
+    isFetchingList: any;
+    isFetchingItem: any;
+    isFetchingLastItems: any;
+    isFetchingPreviousItems: any;
+    isCreating: any;
+    isUpdating: any;
+    isDeleting: any;
+    isSearching: any;
+    isSorting: any;
+    setStatus: (status: LoadingStatus) => void;
+    removeStatus: (status: LoadingStatus) => void;
+};

package/dist/src/composables/UseParams.d.ts

@@ -0,0 +1,15 @@
+import { SortDetail } from '../sort';
+import { BaseModel } from '../BaseModel';
+export declare function useParams(): {
+    params: Ref<Params>;
+    setNextPage: () => void;
+    setPreventPage: () => void;
+    setPageNumber: (pageNumber: number) => void;
+    setItemCount: (itemCount: number) => void;
+    setSortDetail: (sortDetail: SortDetail<BaseModel>) => void;
+    setFilter: (key: string, value: unknown) => void;
+    removeFilter: (key: string) => void;
+    getRequestParams: () => Record<string, unknown>;
+    clearParam: () => void;
+    setFiltersBaseOnRequestBody: (filters: Record<string, unknown>) => void;
+};

package/dist/src/composables/UseRepository.d.ts

@@ -0,0 +1,63 @@
+import { computed } from 'vue';
+import { Repository } from '../repository';
+import { LoadingStatus } from '../constants';
+import { SortDetail } from '../sort';
+import { BaseModel } from '../BaseModel';
+export declare function useRepository<Model extends BaseModel>(repository: Repository<Model>): {
+    loadingStatusManager: {
+        loadingStatus: any;
+        isFetchingList: any;
+        isFetchingItem: any;
+        isFetchingLastItems: any;
+        isFetchingPreviousItems: any;
+        isCreating: any;
+        isUpdating: any;
+        isDeleting: any;
+        isSearching: any;
+        isSorting: any;
+        setStatus: (status: LoadingStatus) => void;
+        removeStatus: (status: LoadingStatus) => void;
+    };
+    dataManger: {
+        itemsAsArray: any;
+        totalCount: any;
+        currentItem: any;
+        setTotalCount: (totalItems: number) => void;
+        addOrReplaceItems: (itemsToAdd: BaseModel[]) => void;
+        getById: (id: number) => computed<BaseModel>;
+        removeById: (id: number) => boolean;
+        clearItems: () => void;
+        setCurrentItem: (item: computed<BaseModel>) => void;
+        clearCurrentItem: () => void;
+    };
+    paramsManager: {
+        params: Ref<Params>;
+        setNextPage: () => void;
+        setPreventPage: () => void;
+        setPageNumber: (pageNumber: number) => void;
+        setItemCount: (itemCount: number) => void;
+        setSortDetail: (sortDetail: SortDetail<BaseModel>) => void;
+        setFilter: (key: string, value: unknown) => void;
+        removeFilter: (key: string) => void;
+        getRequestParams: () => Record<string, unknown>;
+        clearParam: () => void;
+        setFiltersBaseOnRequestBody: (filters: Record<string, unknown>) => void;
+    };
+    tableRenderingData: any;
+    fetchList: (loadingStatus?: LoadingStatus) => Promise<any>;
+    fetchWithAutoRefresh: () => Promise<void>;
+    setupAutoRefresh: () => void;
+    stopAutoRefresh: () => void;
+    fetchItemById: (id: number, shouldRemoveItem?: boolean) => Promise<any>;
+    createItem: <Body>(body: Body) => Promise<any>;
+    updateItem: <Body>(id: number, body: Body) => Promise<any>;
+    deleteItem: (id: number) => Promise<boolean>;
+    fetchLastItems: () => Promise<any>;
+    fetchPreviousItems: () => Promise<any>;
+    fetchItemsByPageNumber: (pageNumber: number) => Promise<any>;
+    search: (searchedValue: string) => Promise<any>;
+    sort: (sortDetail: SortDetail<Model>) => Promise<any>;
+    clearFilters: () => Promise<any>;
+    tableService: any;
+    currentPageItems: any;
+};

package/dist/src/composables/UseStaticTableService.d.ts

@@ -0,0 +1,4 @@
+export declare function useStaticTableService<Model>(initialRows: Model[]): {
+    tableRows: any;
+    staticTableService: any;
+};

package/dist/src/composables/index.d.ts

@@ -0,0 +1,6 @@
+export { useRepository } from './UseRepository';
+export { useData } from './UseData';
+export { useParams } from './UseParams';
+export { useLoadingStatus } from './UseLoadingStatus';
+export { useStaticTableService } from './UseStaticTableService';
+export * from './UseCrud';

package/dist/src/constants/Constants.d.ts

@@ -0,0 +1,108 @@
+export declare const enum LoadingStatus {
+    FetchList = "fetchList",
+    AutoRefresh = "autoRefresh",
+    FetchItem = "fetchItem",
+    FetchLastItems = "fetchLastItems",
+    FetchPreviousItems = "fetchPreviousItems",
+    Create = "CREATE",
+    Update = "UPDATE",
+    Delete = "DELETE",
+    Search = "SEARCH",
+    Sort = "SORT",
+    Success = "SUCCESS",
+    Error = "ERROR",
+    Idle = "IDLE"
+}
+export declare const enum DialogDimensions {
+    Width = "width",
+    Height = "height",
+    DefaultWidth = 500,
+    DefaultHeight = 350,
+    MinimalAvailableSize = 0
+}
+export declare const enum SortOrder {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+export declare const enum SortOrderTableHeader {
+    ASC = "ascend",
+    DESC = "descend"
+}
+export declare const enum TableHeaderAlign {
+    Left = "left",
+    Right = "right",
+    Center = "center"
+}
+export declare const enum HeaderType {
+    Text = "text"
+}
+export declare const enum CellType {
+    Text = "text",
+    ACTION = "action",
+    Tag = "tag",
+    Iban = "iban",
+    BankCard = "bankCard",
+    Symbol = "symbol",
+    TradeDetail = "tradeDetail",
+    SymbolPrice = "symbolPrice",
+    TradeSymbol = "tradeSymbol",
+    Price = "price",
+    DynamicCurrencyPrice = "dynamicCurrencyPrice",
+    TradeDate = "tradeDate",
+    RequestResponseIdentity = "requestResponseIdentity",
+    Image = "image"
+}
+export declare const enum TableConstants {
+    MINIMAL_LOADABLE_HEADER_COUNT = 0,
+    DEFAULT_ITEM_COUNT_PER_PAGE = 20,
+    PAGINATION_POSITION = "bottomCenter"
+}
+export declare const enum ApplicationTheme {
+    FontFamily = "IRANSansX"
+}
+export declare const enum ApplicationDrawerStatus {
+    Open = "open",
+    Close = "close"
+}
+export declare const enum ToastType {
+    Success = "success",
+    Failure = "error",
+    Info = "info",
+    Warning = "warning"
+}
+export declare const enum ToastLocation {
+    BottomLeft = "bottomLeft"
+}
+export declare const enum StatusCode {
+    NotFound = 404,
+    Unauthorized = 401,
+    ServerError = 500
+}
+export declare const enum FormValidationStatus {
+    Invalid = 0,
+    Valid = 1
+}
+export declare const enum StorageKeys {
+    Theme = "theme",
+    AccessList = "accessList",
+    Token = "token",
+    SSO_ACCESS_LIST = "ssoAccessList"
+}
+export declare const enum ApplicationTheme {
+    Light = "light",
+    Dark = "dark"
+}
+export declare const enum ComponentSize {
+    Small = "small",
+    Medium = "medium",
+    Large = "large"
+}
+export declare const enum StoreNames {
+    Dialog = "dialog",
+    Drawer = "drawer",
+    Module = "module",
+    Toast = "toast"
+}
+export declare const enum Symbols {
+    USDT = "USDT"
+}

package/dist/src/constants/index.d.ts

@@ -0,0 +1 @@
+export { LoadingStatus, DialogDimensions, SortOrder, SortOrderTableHeader, TableHeaderAlign, HeaderType, CellType, TableConstants, ApplicationDrawerStatus, ToastType, ToastLocation, StatusCode, FormValidationStatus, StorageKeys, ApplicationTheme, StoreNames } from './Constants';

package/dist/src/crudService/CrudService.d.ts

@@ -0,0 +1,22 @@
+import { SyncDetail, useParams, useCrud, Repository } from '../../index';
+import { BaseModel } from '../BaseModel';
+export declare class CrudService<Entity extends BaseModel> {
+    protected repository: Repository<Entity>;
+    protected crudDataManagement: ReturnType<typeof useCrud>;
+    protected scheduler: any;
+    protected syncDetail: SyncDetail;
+    paramManager: any;
+    constructor(repository: Repository<Entity>, crudDataManagement: ReturnType<typeof useCrud>, paramManager: ReturnType<typeof useParams>);
+    fetchList(): Promise<any>;
+    fetchItemById(id: number): Promise<any>;
+    createItem<Body>(body: Body): Promise<any>;
+    protected shouldRefreshListAfterCreate(): boolean;
+    deleteItem(id: number): Promise<any>;
+    updateItem<Body>(id: number, body: Body): Promise<any>;
+    protected shouldRefreshListAfterUpdate(): boolean;
+    removeItem(id: number): Promise<any>;
+    protected shouldRefreshListAfterDelete(): boolean;
+    private syncListWithApi;
+    onDestroy(): void;
+    clearInterval(): void;
+}

package/dist/src/crudService/index.d.ts

@@ -0,0 +1 @@
+export * from './CrudService';

package/dist/src/dateHandling/Constants.d.ts

@@ -0,0 +1,5 @@
+export declare const enum DateFormats {
+    Normal = "YYYY-MM-DD",
+    ContainsHour = "YYYY-MM-DD HH:mm",
+    OnlyHour = "HH:mm"
+}

package/dist/src/dateHandling/Converter.d.ts

@@ -0,0 +1,5 @@
+export declare class DateConverter {
+    static standardToUnix(dateToConvert: string): number;
+    static unixToStandard(dateToConvert: number): string;
+    static getUnixEndOfDayInUnix(unix: number): any;
+}

package/dist/src/dateHandling/JalaliDateSetup.d.ts

@@ -0,0 +1 @@
+export declare function setupJalaliDate(): void;

package/dist/src/dateHandling/Model.d.ts

@@ -0,0 +1,12 @@
+import { Nullable } from '../types';
+export declare class RangeValue {
+    start: number;
+    end: number;
+    constructor(start: number, end: number);
+}
+export declare class DateDisabledOptions {
+    maxDate: Nullable<number>;
+    minDate: Nullable<number>;
+    disabledDates: number[];
+    constructor(max: Nullable<number>, min: Nullable<number>, disabledDates: number[]);
+}

package/dist/src/dateHandling/Utils.d.ts

@@ -0,0 +1,8 @@
+import { DateDisabledOptions } from './Model';
+import { default as dayjs } from 'dayjs';
+export declare class DateTools {
+    static isDateDisabled(options: DateDisabledOptions, date: dayjs.Dayjs): boolean;
+    static areUnixesInSameDate(firstDate: number, secondDate: number): boolean;
+    static isDateGraterOrSame(originDate: number, dateToCheck: number): boolean;
+    static isDateLowerOrSame(originDate: number, dateToCheck: number): boolean;
+}

package/dist/src/dateHandling/index.d.ts

@@ -0,0 +1,5 @@
+export { DateFormats } from './Constants';
+export { setupJalaliDate } from './JalaliDateSetup';
+export { RangeValue, DateDisabledOptions } from './Model';
+export { DateTools } from './Utils';
+export { DateConverter } from './Converter';

package/dist/src/debounce/DebounceAction.d.ts

@@ -0,0 +1,4 @@
+export interface DebounceAction {
+    runDebounce: () => void;
+    runImmediate: () => void;
+}

package/dist/src/debounce/DebounceService.d.ts

@@ -0,0 +1,9 @@
+import { DebounceAction } from './DebounceAction';
+export declare class DebounceService {
+    private readonly debounceTimeout;
+    private action;
+    private timerId;
+    constructor(action: DebounceAction, debounceTimeout?: number);
+    runAction(): void;
+    cancelDebounce(): void;
+}

package/dist/src/debounce/index.d.ts

@@ -0,0 +1,2 @@
+export { type DebounceAction } from './DebounceAction';
+export { DebounceService } from './DebounceService';

package/dist/src/deviceManagement/Constants.d.ts

@@ -0,0 +1,4 @@
+export declare const enum VisibilityState {
+    Hidden = "hidden",
+    Visible = "visible"
+}

package/dist/src/deviceManagement/Visibility.d.ts

@@ -0,0 +1,4 @@
+export interface Visibility {
+    screenVisible(event: Event): Promise<void>;
+    screenInvisible(event: Event): Promise<void>;
+}

package/dist/src/deviceManagement/VisibilityManager.d.ts

@@ -0,0 +1,6 @@
+import { Visibility } from './Visibility';
+export declare class VisibilityManager {
+    private _visibilityControl;
+    constructor(_visibilityControl: Visibility);
+    private mangeVisibilityEvent;
+}

package/dist/src/deviceManagement/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Constants';
+export * from './VisibilityManager';
+export * from './Visibility';

package/dist/src/errorHandling/ErrorHandler.d.ts

@@ -0,0 +1,3 @@
+export interface ErrorHandler {
+    handleError(error: Error): Promise<void>;
+}

package/dist/src/errorHandling/HandleError.d.ts

@@ -0,0 +1,2 @@
+import { ErrorHandler } from './ErrorHandler';
+export declare function HandleError(handlers: ErrorHandler[]): (_name: unknown, _target: unknown, descriptor: PropertyDescriptor) => void;

package/dist/src/errorHandling/index.d.ts

@@ -0,0 +1,2 @@
+export type { ErrorHandler } from './ErrorHandler';
+export { HandleError } from './HandleError';

package/dist/src/feedbackHandling/FailureFeedback.d.ts

@@ -0,0 +1,3 @@
+export interface FailureFeedback<ErrorModel> {
+    handleFailure(error: ErrorModel): Promise<void>;
+}

package/dist/src/feedbackHandling/Feedback.d.ts

@@ -0,0 +1,11 @@
+export declare abstract class Feedback<Model, ErrorModel extends Error = Error> {
+    protected successMessageResolver: (model: Model) => string;
+    protected failureMessageResolver: (error: ErrorModel) => string;
+    shouldResolveSuccess: (model: Model) => boolean;
+    shouldResolveFailure: (error: ErrorModel) => boolean;
+    constructor(successMessageResolver: (model: Model) => string, failureMessageResolver: (error: ErrorModel) => string, shouldResolveSuccess?: (model: Model) => boolean, shouldResolveFailure?: (error: ErrorModel) => boolean);
+    handleSuccess(entity: Model): Promise<void>;
+    handleFailure(error: ErrorModel): Promise<void>;
+    handleInfo(): Promise<void>;
+    handleWarning(): Promise<void>;
+}

package/dist/src/feedbackHandling/HandleFeedback.d.ts

@@ -0,0 +1,2 @@
+import { Feedback } from './Feedback';
+export declare function HandleFeedback<Model>(feedbacks: Feedback<Model>[]): (_name: unknown, _target: unknown, descriptor: PropertyDescriptor) => void;

package/dist/src/feedbackHandling/InfoFeedback.d.ts

@@ -0,0 +1,3 @@
+export interface InfoFeedback {
+    handleInfo(): Promise<void>;
+}

package/dist/src/feedbackHandling/SuccessFeedback.d.ts

@@ -0,0 +1,3 @@
+export interface SuccessFeedback<Model> {
+    handleSuccess(model: Model): Promise<void>;
+}

package/dist/src/feedbackHandling/WarningFeedback.d.ts

@@ -0,0 +1,3 @@
+export interface WarningFeedback {
+    handleWarning(): Promise<void>;
+}

package/dist/src/feedbackHandling/index.d.ts

@@ -0,0 +1,6 @@
+export { HandleFeedback } from './HandleFeedback';
+export { Feedback } from './Feedback';
+export type { FailureFeedback } from './FailureFeedback';
+export type { InfoFeedback } from './InfoFeedback';
+export type { SuccessFeedback } from './SuccessFeedback';
+export type { WarningFeedback } from './WarningFeedback';

package/dist/src/httpClient/ApiBuilder.d.ts

@@ -0,0 +1,14 @@
+import { Axios } from 'axios';
+import { Interceptor } from './Interceptor';
+import { APIErrorHandlerRegistry } from './ErrorHandlerRegistry';
+export declare class ApiBuilder {
+    private axiosInstance;
+    constructor(axiosInstance: Axios);
+    setBaseURL(baseURL: string): this;
+    setTimeout(timeInMilliSeconds: number): this;
+    setHeaders(headers: Record<string, string | string[]>): this;
+    attachRequestInterceptors(interceptors: Interceptor[]): this;
+    attachResponseInterceptors(apiErrorRegistry: APIErrorHandlerRegistry): this;
+    build(): Axios;
+}
+export default ApiBuilder;

package/dist/src/httpClient/ErrorHandlerRegistry.d.ts

@@ -0,0 +1,10 @@
+import { AxiosError } from 'axios';
+import { ErrorHandler } from '../errorHandling';
+export declare class APIErrorHandlerRegistry {
+    private static handlers;
+    private static instance;
+    private constructor();
+    static GetInstance(): Nullable<APIErrorHandlerRegistry>;
+    static registerHandler(statusCode: number, handler: ErrorHandler): void;
+    handle(error: AxiosError): void;
+}

package/dist/src/httpClient/HttpClient.d.ts

@@ -0,0 +1,14 @@
+import { Axios, AxiosHeaders, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+type axiosConfig = {
+    headers?: AxiosHeaders;
+} & Omit<InternalAxiosRequestConfig, "headers">;
+export declare class HttpClient {
+    private axiosInstance;
+    constructor(instance: Axios);
+    get<T>(url: string, config?: axiosConfig): Promise<AxiosResponse<T>>;
+    post<T>(url: string, data?: unknown, config?: axiosConfig): Promise<AxiosResponse<T>>;
+    patch<T>(url: string, data?: unknown, config?: axiosConfig): Promise<AxiosResponse<T>>;
+    put<T>(url: string, data?: unknown, config?: axiosConfig): Promise<AxiosResponse<T>>;
+    delete<T>(url: string, config?: axiosConfig): Promise<AxiosResponse<T>>;
+}
+export default HttpClient;

package/dist/src/httpClient/Interceptor.d.ts

@@ -0,0 +1,4 @@
+import { InternalAxiosRequestConfig } from 'axios';
+export interface Interceptor {
+    intercept(config: InternalAxiosRequestConfig): InternalAxiosRequestConfig;
+}

package/dist/src/httpClient/index.d.ts

@@ -0,0 +1,4 @@
+export { APIErrorHandlerRegistry } from './ErrorHandlerRegistry';
+export { ApiBuilder } from './ApiBuilder';
+export { HttpClient } from './HttpClient';
+export { type Interceptor } from './Interceptor';

package/dist/src/initializer/ApplicationInitializer.d.ts

@@ -0,0 +1,6 @@
+import { Initializer } from './Initializer';
+export declare class ApplicationInitializer {
+    private _initializer;
+    setupInitializers(initializers: Initializer[]): void;
+    initialize(): void;
+}

package/dist/src/initializer/Initializer.d.ts

@@ -0,0 +1,3 @@
+export interface Initializer {
+    initialize(): void;
+}

package/dist/src/initializer/index.d.ts

@@ -0,0 +1,2 @@
+export { ApplicationInitializer } from './ApplicationInitializer';
+export { type Initializer } from './Initializer';

package/dist/src/json/JsonMapper.d.ts

@@ -0,0 +1,18 @@
+export declare class JsonMapper {
+    private static Instance;
+    private jsonConverter;
+    private constructor();
+    serializeObject<T extends object>(object: object, model: {
+        new (): T;
+    }): any;
+    deserializeObject<T extends object>(object: object, model: {
+        new (): T;
+    }): any;
+    deserializeArray<T extends object>(array: Array<T>, model: {
+        new (): T[];
+    }): any;
+    tryDeserialize(object: object, models: {
+        new (): any;
+    }[]): any;
+    static GetInstance(): Nullable<JsonMapper>;
+}

package/dist/src/json/index.d.ts

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