@evercam/api 1.0.0-0a308274b

package/README.md

@@ -0,0 +1 @@
+# @evercam/api

package/dist/api/3dFirebaseApi.d.ts

@@ -0,0 +1,9 @@
+import { _360ProjectJsonResponse, DroneProjectJsonResponse, ProjectExid } from "@evercam/api/types";
+export declare const _3dFirebaseApi: {
+    drone: {
+        getProjectInfo(projectExid: ProjectExid): Promise<DroneProjectJsonResponse>;
+    };
+    _360: {
+        getProjectInfo(projectExid: ProjectExid): Promise<_360ProjectJsonResponse>;
+    };
+};

package/dist/api/adminApi.d.ts

@@ -0,0 +1,307 @@
+import { FootageCreateUpdatePayload, HDDCreateUpdatePayload, HDDsQueryParams } from "@/types/hdd";
+import type { CamerasResponsePayload, CameraUpdateRequestPayload, PaginatedItems, AdminCamera, Project, Hdd, AdminUser, ProgressPhotosCreateUpdateRequestPayload, ProgressPhoto, Kit, PatchPayload, StorageServersResponsePayload, MediaFilterQueryParams, Media, MediaDeleteRequestPayload, AuditLogsParams, AuditLog, SnapshotExtractionQyeryParams, SnapshotExtraction, CameraCreateRequestPayload, CameraDeletePayload, SnapshotTestPayload, SnapshotTestResponse, DuplicatedCameraFields, DuplicatedCameraResponse, MergeDuplicatedCameraPayload, FetchCameraQueryParams, DeleteSnapshotQueryParams, SaveNotePayload, CameraNote, CreateCameraNotePayload, CompanyQueryParams, Company, CompanyUpdatePayload, SuppressionsQueryParams, Suppression, SnapshotExtractionType, PaginationParams, GateReportProject, KitQueryParams, KitCreatePayload, AdminKit, CameraLogsQueryParams, CameraLog, CameraAuditLogsQueryParams, CameraAuditLog, NvrQueryParams, Nvr, SiteVisitCamerasQueryParams, OfflineCameraQueryParams, OfflineCamera, OfflineCameraNoteResponse, UserStatsResponse, EntityStatsQueryParams, EntityStat, UserSession, UserCameraResponse, UserProjectResponse, ProjectUsers, ProjectCamera, ProjectsQueryParams, ProjectStatusStats, ProjectCreateRequestPayload, ProjectCreateResponse, ProjectUpdateRequestPayload, RouterQueryParams, Router, RouterCreatePayload, GlobalSearchQueryParams, CameraShareRequestsQueryParams, CameraShareRequest, CameraShareRequestPayload, ShareCreateResponsePayload, ShareQueryParams, AdminShare, SimCreateUpdatePayload, SimsQueryParams, Sim, SendSmsPayload, SendSmsResponse, SmsHistoryResponse, SmsQueryParams, Sms, ProgressPhotosQueryParams, ProgressPhotoItem, progressPhotosHistoryQueryParams, ProgressPhotosHistory, AdminUserUpdateRequestPayload, AdminQueryParams, Admin, ImpersonateUserResponse, AdminUserQueryParams, AdminCompareQueryParams, AdminCompare, NvrCreatePayload, WidgetsListRequestPayload, Widget, WidgetFull, WidgetPayload } from "@evercam/api/types";
+import { KitMetricId } from "@evercam/api/types";
+export declare const AdminApi: {
+    mediaHub: {
+        getAllMedia(params: {
+            params: Partial<MediaFilterQueryParams>;
+        }): Promise<PaginatedItems<Media>>;
+        deleteMedia(params: Partial<MediaDeleteRequestPayload>): Promise<void>;
+    };
+    auditLogs: {
+        getAuditLogs(params: {
+            params: Partial<AuditLogsParams>;
+        }): Promise<PaginatedItems<AuditLog>[]>;
+    };
+    cameras: {
+        getCamerasStats(params: {
+            params: {
+                email?: string;
+            };
+        }): Promise<CamerasResponsePayload>;
+        rebootCamera(cameraId: string): Promise<{
+            message: string;
+        }>;
+        focusCamera(cameraId: string, device: string): Promise<{
+            message: string;
+        }>;
+        getStorageServers(): Promise<StorageServersResponsePayload>;
+        getStorageDetails(): Promise<import("axios").AxiosResponse<any, any>>;
+        getSnapshotExtractions(params: {
+            params: Partial<SnapshotExtractionQyeryParams>;
+        }): Promise<PaginatedItems<SnapshotExtraction>>;
+        createCameras(payload: CameraCreateRequestPayload): Promise<{
+            cameras: [AdminCamera];
+        }>;
+        deleteCamera(exid: string, payload: CameraDeletePayload): Promise<void>;
+        testSnapshot(payload: SnapshotTestPayload): Promise<SnapshotTestResponse>;
+        getDuplicateCameras(params: {
+            params: {
+                fields?: DuplicatedCameraFields[];
+                sort?: string;
+            };
+        }): Promise<PaginatedItems<DuplicatedCameraResponse>>;
+        mergeDuplicateCameras(payload: MergeDuplicatedCameraPayload): Promise<{
+            success: boolean;
+        }>;
+        getCameras(params: {
+            params: Partial<FetchCameraQueryParams>;
+        }): Promise<PaginatedItems<AdminCamera>>;
+        getCompares(params: {
+            params: AdminCompareQueryParams;
+        }): Promise<PaginatedItems<AdminCompare[]>>;
+        getCameraDetails(exid: string): Promise<AdminCamera>;
+        deleteSnapshots(cameraId: string, params: DeleteSnapshotQueryParams): Promise<void>;
+        refreshDeviceSettings(cameraId: string): Promise<void>;
+        saveNote(cameraId: string, params: SaveNotePayload): Promise<CameraNote>;
+        saveCameraNote(cameraId: string, params: CreateCameraNotePayload): Promise<{
+            message: string;
+        }>;
+        update(cameraId: string, params: CameraUpdateRequestPayload): Promise<CamerasResponsePayload>;
+    };
+    companies: {
+        getCompanies(params: {
+            params: Partial<CompanyQueryParams>;
+        }): Promise<PaginatedItems<Company[]>>;
+        updateCompany(id: string, params: CompanyUpdatePayload): Promise<Omit<CompanyUpdatePayload, "linkedinUrl">>;
+        deleteCompany(params: {
+            ids: string | string[];
+        }): Promise<{
+            success: true;
+        }>;
+        reSyncCompanies(params: {
+            companyIds: string[];
+        }): Promise<{
+            success: true;
+        }>;
+    };
+    emailing: {
+        performEmailing(template: string, params: Record<string, unknown>): Promise<import("axios").AxiosResponse<any, any>>;
+        suppressions(params: {
+            params: SuppressionsQueryParams;
+        }): Promise<PaginatedItems<Suppression[]>>;
+        deleteSuppression(id: number): Promise<void>;
+    };
+    extractions: {
+        updateCloudRecordings(cameraId: string, params: Record<string, unknown>): Promise<import("axios").AxiosResponse<any, any>>;
+        addExtraction(cameraId: string, params: SnapshotExtractionQyeryParams): Promise<PaginatedItems<SnapshotExtraction>>;
+        getExtractionStatus(cameraId: string, extractionId: number, params: {
+            type: SnapshotExtractionType;
+        }): Promise<{
+            status: string;
+            jpegs: number;
+        }>;
+        deleteSnapshotExtraction(cameraId: string, extractionId: number, params: {
+            type: SnapshotExtractionType;
+        }): Promise<void>;
+    };
+    gateReport: {
+        getGateReportProjects(params: {
+            params: PaginationParams;
+        }): Promise<PaginatedItems<GateReportProject[]>>;
+        getGateReportProject(projectExid: string): Promise<Project>;
+    };
+    kits: {
+        getAllKits(params: {
+            params: KitQueryParams;
+        }): Promise<PaginatedItems<Kit[]>>;
+        getKit(kitId: number): Promise<Kit>;
+        createKit(params: KitCreatePayload): Promise<AdminKit>;
+        updateKit(id: string, params: PatchPayload<Kit>): Promise<import("axios").AxiosResponse<any, any>>;
+        deleteKit(id: string, params: Record<string, unknown>): Promise<import("axios").AxiosResponse<any, any>>;
+        getKitStats({ kitId, metric, fromDate, toDate, }: {
+            kitId: number;
+            metric: KitMetricId;
+            fromDate: string;
+            toDate: string;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    logs: {
+        getAllCamerasStatusLogs(params: {
+            params: CameraLogsQueryParams;
+        }): Promise<{
+            data: CameraLog[];
+        }>;
+        getCameraLogs(cameraId: string, payload: {
+            params: CameraAuditLogsQueryParams;
+        }): Promise<PaginatedItems<CameraAuditLog[]>>;
+        togglePinNote(id: string): Promise<PaginatedItems<CameraAuditLog[]>>;
+    };
+    nvrs: {
+        getNvrs(params: {
+            params: NvrQueryParams;
+        }): Promise<PaginatedItems<Nvr[]>>;
+        createNvr(params: NvrCreatePayload): Promise<import("axios").AxiosResponse<any, any>>;
+        updateNvr(id: string, params: PatchPayload<Nvr>): Promise<import("axios").AxiosResponse<any, any>>;
+        rebootNVR(cameraId: string): Promise<{
+            message: string;
+        }>;
+    };
+    offlineCameras: {
+        getSiteVisitCameras(params: {
+            params: Partial<SiteVisitCamerasQueryParams>;
+        }): Promise<PaginatedItems<AdminCamera>>;
+        getOfflineCameras(params: {
+            params: Partial<OfflineCameraQueryParams>;
+        }): Promise<PaginatedItems<OfflineCamera>>;
+        getOfflineCamerasLastNote(params: {
+            cameraIds: number[];
+        }): Promise<OfflineCameraNoteResponse>;
+    };
+    pa: {
+        getPAUser(id: number, params: Record<string, unknown>): Promise<UserStatsResponse>;
+        getPAProjectPeriodEvents(id: string | number, payload: EntityStatsQueryParams): Promise<EntityStat[]>;
+        getPAUserEvents(id: string | number): Promise<UserSession[]>;
+        getPAUserCameras(id: number): Promise<UserCameraResponse>;
+        getPAUserProjects(id: number): Promise<UserProjectResponse>;
+        getPAUserPeriodEvents(id: number, payload: EntityStatsQueryParams): Promise<EntityStat[]>;
+        getProjectUsers(id: string): Promise<ProjectUsers>;
+        getPAProject(id: string, params: Record<string, unknown>): Promise<{
+            data: Project;
+        }>;
+        getPAProjectCameras(id: string): Promise<{
+            data: ProjectCamera[];
+        }>;
+    };
+    projects: {
+        getAll(params: {
+            params: Partial<ProjectsQueryParams>;
+        }): Promise<PaginatedItems<Project>>;
+        getProject(exid: string): Promise<Project>;
+        getProjectsStats(): Promise<ProjectStatusStats>;
+        createProject(params: ProjectCreateRequestPayload): Promise<ProjectCreateResponse>;
+        updateProject(projectExid: string, params: Partial<ProjectUpdateRequestPayload>): Promise<ProjectCreateResponse>;
+        deleteProject(projectExid: string): Promise<{
+            success: boolean;
+        }>;
+        addToProject(projectExid: string, params: {
+            cameraExids: string[];
+        }): Promise<void>;
+    };
+    routers: {
+        getRouters(params: {
+            params: Partial<RouterQueryParams>;
+        }): Promise<PaginatedItems<Router[]>>;
+        getRouterTypes(): Promise<string[]>;
+        createRouter(params: RouterCreatePayload): Promise<{
+            routerId: number;
+        }>;
+        updateRouter(id: number, params: RouterCreatePayload): Promise<{
+            success: boolean;
+        }>;
+        deleteRouter(id: number): Promise<void>;
+        getRouter(id: number): Promise<Router>;
+    };
+    search: {
+        search(params: {
+            params: GlobalSearchQueryParams;
+        }): Promise<PaginatedItems<Record<string, unknown>>>;
+    };
+    hdds: {
+        getHdds(payload: {
+            projectId: string;
+            companyId: string;
+        }): Promise<Hdd[]>;
+        getAllHdds(params: {
+            params: Partial<HDDsQueryParams>;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        deleteHdd(hddId: number): Promise<import("axios").AxiosResponse<any, any>>;
+        saveHdd(params: HDDCreateUpdatePayload): Promise<import("axios").AxiosResponse<any, any>>;
+        updateHdd(hddId: number, params: HDDCreateUpdatePayload): Promise<import("axios").AxiosResponse<any, any>>;
+        saveFootage(hddId: number, params: FootageCreateUpdatePayload): Promise<import("axios").AxiosResponse<any, any>>;
+        deleteFootage(hddId: number, footageId: number): Promise<import("axios").AxiosResponse<any, any>>;
+        updateFootage(hddId: number, footageId: number, params: FootageCreateUpdatePayload): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    shareRequests: {
+        getShareRequests(params: {
+            params: Partial<CameraShareRequestsQueryParams>;
+        }): Promise<PaginatedItems<CameraShareRequest[]>>;
+        deleteShareRequest(params: {
+            ids: number[];
+        }): Promise<{
+            success: boolean;
+        }>;
+        updateShareRequestStatus(params: {
+            ids: number[];
+            status: string;
+        }): Promise<{
+            success: boolean;
+        }>;
+    };
+    shares: {
+        createShares(cameraExid: string, payload: CameraShareRequestPayload): Promise<ShareCreateResponsePayload>;
+        getShares(params: {
+            params: Partial<ShareQueryParams>;
+        }): Promise<PaginatedItems<AdminShare[]>>;
+        deleteShares(ids: number[]): Promise<void>;
+    };
+    sims: {
+        deleteSim(simId: number): Promise<{
+            deleted: boolean;
+        }>;
+        createSim(params: Omit<SimCreateUpdatePayload, "cameraId">): Promise<{
+            success: boolean;
+        }>;
+        updateSim(simId: number, params: CameraShareRequestPayload): Promise<{
+            success: boolean;
+        }>;
+        getSims(params: {
+            params: Partial<SimsQueryParams>;
+        }): Promise<PaginatedItems<Sim[]>>;
+        getSimProviders(): Promise<import("axios").AxiosResponse<any, any>>;
+        getBillPayers(): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    sms: {
+        sendSms(number: string, params: SendSmsPayload): Promise<SendSmsResponse>;
+        getSimHistory(number: string): Promise<SmsHistoryResponse>;
+        getSms(params: {
+            params: Partial<SmsQueryParams>;
+        }): Promise<PaginatedItems<Sms[]>>;
+    };
+    progressPhotos: {
+        getProgressPhotos(params: {
+            params: Partial<ProgressPhotosQueryParams>;
+        }): Promise<PaginatedItems<ProgressPhotoItem[]>>;
+        getProgressPhotosHistory(params: {
+            params: Partial<progressPhotosHistoryQueryParams>;
+        }): Promise<ProgressPhotosHistory>;
+        getProgressPhotoTemplate({ id, }: {
+            id: string;
+        }): Promise<{
+            progressPhoto: string;
+        }>;
+        update(id: string, payload: ProgressPhotosCreateUpdateRequestPayload): Promise<ProgressPhoto>;
+    };
+    users: {
+        updateUser(id: number, params: Partial<AdminUserUpdateRequestPayload>): Promise<AdminUser>;
+        getAdmins(params: {
+            params: Partial<AdminQueryParams>;
+        }): Promise<PaginatedItems<Admin[]>>;
+        deleteAdmin(email: string): Promise<void | {
+            message: string;
+        }>;
+        makeAdmin(email: string): Promise<void | {
+            message: string;
+        }>;
+        deleteUser(email: string, params: {
+            verifyEmail: string;
+        }): Promise<void | {
+            message: string;
+        }>;
+        impersonateUser(email: string): Promise<ImpersonateUserResponse>;
+        getUsers(params: {
+            params: Partial<AdminUserQueryParams>;
+        }): Promise<PaginatedItems<AdminUser>>;
+        getUserPasswordResetLink(email: string): Promise<{
+            passwordResetLink: string;
+        }>;
+    };
+    widgets: {
+        index(params: {
+            params: Partial<WidgetsListRequestPayload>;
+        }): Promise<PaginatedItems<Widget>>;
+        show(id: number): Promise<WidgetFull>;
+        update(id: number, payload: WidgetPayload): Promise<WidgetFull>;
+        delete(id: number): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+};

package/dist/api/aiApi.d.ts

@@ -0,0 +1,86 @@
+import type { AnprQueryParams, AnprEvent, EventCountRequestPayload, EventCountResponsePayload, EventsExportRequestParameters, EventsRequestPayload, EventsResponsePayload, GateReportROI, PaginatedItems, GateReportVerifiedDay, ProjectExid, CameraExid, AnprCountsQueryParams, AnprCount, AnprBasedGateReportExportRequestParams, GateReportResponsePayload, GatReportRequestPayload, AnalyticsParameters, VerifiedDaysQueryParams, EventUpdateRequestPayload, VerifyDayUpdateRequestPayload, ProcessedDaysQueryParams, GateReportEventType, DateTime, RoisQueryParams, GateReportROICreateRequestPayload, SegmentsSimilaritySearchParams, DetectionsFilters, TrackingsByLabel, SegmentsByLabel, CountsParams, DetectionsPresenceByLabel } from "@evercam/api/types";
+import type { AxiosPromise, AxiosRequestConfig } from "axios";
+export declare const getAiApiUrl: () => string | null | undefined;
+export declare const AiApi: {
+    analyticsParameters: {
+        getParameters(cameraId: CameraExid, params?: Record<string, unknown>): Promise<AnalyticsParameters>;
+        createParameters(params: Omit<AnalyticsParameters, "id">): Promise<AnalyticsParameters>;
+        updateParameters({ updatedBy, id, ...payload }: Partial<AnalyticsParameters> & {
+            updatedBy: string;
+        }): Promise<AnalyticsParameters>;
+    };
+    anpr: {
+        exportAnprLegacyEvents(projectExid: ProjectExid, params: AnprQueryParams): AxiosPromise<any>;
+        getAnprEvents(projectExid: ProjectExid, params: AnprQueryParams): Promise<PaginatedItems<AnprEvent>>;
+        getAnprCounts(projectExid: ProjectExid, payload: AnprCountsQueryParams): Promise<AnprCount[]>;
+        updateAnprEvent(anprEventId: string, eventBody: Record<string, unknown>): Promise<import("axios").AxiosResponse<any, any>>;
+        bulkUpdateAnprRecords(anprEventsIds: number[], action: "is_plate" | "not_plate" | "is_duplicate" | "not_duplicate"): Promise<import("axios").AxiosResponse<any, any>>;
+        exportAnprEvents(projectExid: string, params: AnprBasedGateReportExportRequestParams): AxiosPromise<string>;
+    };
+    gateReport: {
+        getGateReportProjects(params: Record<string, unknown>): Promise<import("axios").AxiosResponse<any, any>>;
+        getLastVerified(params: Record<string, unknown>): Promise<import("axios").AxiosResponse<any, any>>;
+        deleteEvent(id: number, params: Record<string, unknown>): Promise<import("axios").AxiosResponse<any, any>>;
+        dismissEvents(params: Record<string, unknown>): Promise<import("axios").AxiosResponse<any, any>>;
+        exportEvents(projectExid: string, params: EventsExportRequestParameters): AxiosPromise<any>;
+        exportEventsProgress(projectExid: string, params: {
+            exportDate: string;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        getAllEvents(projectExid: ProjectExid, params: EventsRequestPayload, extraParams?: AxiosRequestConfig): Promise<EventsResponsePayload>;
+        getEventCounts(projectExid: string, payload?: EventCountRequestPayload, extraParams?: AxiosRequestConfig): Promise<EventCountResponsePayload>;
+        getVerifiedDays(projectExid: ProjectExid, params: Partial<VerifiedDaysQueryParams>, extraParams?: {}): Promise<PaginatedItems<GateReportVerifiedDay>>;
+        updateEventById(eventId: number, { updatedBy, payload, }: {
+            updatedBy: string;
+            payload: Partial<EventUpdateRequestPayload>;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        verifyDay(params: VerifyDayUpdateRequestPayload): Promise<import("axios").AxiosResponse<any, any>>;
+        regenerateThumbnail(id: number, params: {
+            cameraExid: string;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        getDailyStatus(projectExid: string, params?: Partial<ProcessedDaysQueryParams>): Promise<import("axios").AxiosResponse<any, any>>;
+        getEventThumbnail({ cameraExid, eventType, eventTime, token, }: {
+            cameraExid: string;
+            eventType: GateReportEventType;
+            eventTime: DateTime;
+            token: string;
+        }): string;
+        getEventSnapshot({ cameraExid, eventType, eventTime, token, }: {
+            cameraExid: string;
+            eventType: GateReportEventType;
+            eventTime: DateTime;
+            token: string;
+        }): string;
+        getEvents(projectExid: ProjectExid, params: GatReportRequestPayload, extraParams?: AxiosRequestConfig): Promise<GateReportResponsePayload>;
+        getCounts(projectExid: string, payload?: EventCountRequestPayload, extraParams?: AxiosRequestConfig): Promise<EventCountResponsePayload>;
+    };
+    brainTool: {
+        getObjectDetectionsResults(payload?: {}): Promise<import("axios").AxiosResponse<any, any>>;
+        getSegments(payload?: {}): Promise<import("axios").AxiosResponse<any, any>>;
+        getDepth(cameraExid: string, timestamp: string): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    roi: {
+        getROIs(projectExid: string, params?: Partial<RoisQueryParams>): Promise<GateReportROI[]>;
+        createROI(params: GateReportROICreateRequestPayload): Promise<import("axios").AxiosResponse<any, any>>;
+        updateROI({ updatedBy, roi, }: {
+            updatedBy: string;
+            roi: GateReportROICreateRequestPayload;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        deleteROI({ id, updatedBy }: {
+            id: number;
+            updatedBy: string;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    detections: {
+        getSimilarSegmentsInTimeIntervals({ cameraExid, iouThreshold, ...params }: SegmentsSimilaritySearchParams): Promise<import("axios").AxiosResponse<any, any>>;
+        getDetectionsTracking(cameraExid: CameraExid, params: DetectionsFilters): Promise<TrackingsByLabel>;
+        getSegmentsMasks(cameraExid: CameraExid, params: DetectionsFilters): Promise<SegmentsByLabel>;
+        getDetectionsPresenceDateIntervals({ cameraExid, ...params }: CountsParams): Promise<DetectionsPresenceByLabel>;
+    };
+    siteAnalytics: {
+        smartSearch({ cameraExid, query, payload, }: {
+            cameraExid: CameraExid;
+            query: Record<string, unknown>;
+            payload: Record<string, unknown>;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+};

package/dist/api/authzApi.d.ts

@@ -0,0 +1,21 @@
+export declare const AuthzApi: {
+    roles: {
+        get(params: any): Promise<import("axios").AxiosResponse<any, any>>;
+        getRoleDetails(id: number): Promise<import("axios").AxiosResponse<any, any>>;
+        createRole(params: any): Promise<import("axios").AxiosResponse<any, any>>;
+        updateRole(id: number, params: any): Promise<import("axios").AxiosResponse<any, any>>;
+        deleteRole(id: number): Promise<import("axios").AxiosResponse<any, any>>;
+        addPermission(id: number, action: string): Promise<import("axios").AxiosResponse<any, any>>;
+        deletePermission(id: number, action: string): Promise<import("axios").AxiosResponse<any, any>>;
+        getRoleUsers(id: number): Promise<import("axios").AxiosResponse<any, any>>;
+        assignUsers(id: number, emails: Array<string>, resource_id: string): Promise<import("axios").AxiosResponse<any, any>>;
+        unassignUsers(id: number, emails: Array<string>, resource_id: string): Promise<import("axios").AxiosResponse<any, any>>;
+        getUserRoles(): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    scopes: {
+        get(): Promise<import("axios").AxiosResponse<any, any>>;
+        create(params: any): Promise<import("axios").AxiosResponse<any, any>>;
+        delete(id: number): Promise<import("axios").AxiosResponse<any, any>>;
+        update(id: number, params: any): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+};

package/dist/api/client/axios.d.ts

@@ -0,0 +1,13 @@
+import type { ExtendedAxiosInstance } from "@/types";
+declare module "axios" {
+    interface AxiosRequestConfig {
+        raw?: boolean;
+        preserveCasing?: boolean;
+        timing?: boolean;
+        _metadata?: {
+            startTime: number;
+        };
+    }
+}
+declare const axios: ExtendedAxiosInstance;
+export { axios };

package/dist/api/client/customErrors.d.ts

@@ -0,0 +1,80 @@
+export declare const BadRequestError: {
+    new (error: unknown): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};
+export declare const NotFoundError: {
+    new (error: unknown): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};
+export declare const UnauthorizedError: {
+    new (error: unknown): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};
+export declare const GatewayTimeoutError: {
+    new (error: unknown): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};
+export declare const BadGatewayError: {
+    new (error: unknown): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};
+export declare const ForbiddenError: {
+    new (error: unknown): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};
+export declare const HlsError: {
+    new (error: unknown): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};
+export declare const SnapshotError: {
+    new (error: unknown): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};
+export declare const ConflictError: {
+    new (error: unknown): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};
+export declare const InternalServerError: {
+    new (error: unknown): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+};

package/dist/api/client/index.d.ts

@@ -0,0 +1,5 @@
+import { axios } from "./axios";
+export * from "./customErrors";
+export * from "./interceptors";
+export { axios };
+export default axios;

package/dist/api/client/interceptors.d.ts

@@ -0,0 +1,10 @@
+import { AxiosDefaults, type AxiosError, type AxiosRequestConfig, type AxiosResponse } from "axios";
+import type { AxiosEnvironment } from "../../types";
+export declare const onRequest: (request: AxiosRequestConfig, axiosEnv: AxiosEnvironment) => Promise<AxiosRequestConfig<any>>;
+export declare const onResponse: (response: AxiosResponse) => any;
+export declare const onError: (error: AxiosError, axiosEnv: AxiosEnvironment) => Promise<{
+    error: AxiosError<unknown, any>;
+    duration: number;
+}>;
+export declare const ensureCommonHeaders: (target: AxiosDefaults | AxiosRequestConfig) => void;
+export declare const OnRequestExpiredTokenInterceptor: (request: AxiosRequestConfig, isTokenExpired: () => boolean, handler: () => Promise<void>) => Promise<AxiosRequestConfig<any>>;