@evercam/api 1.0.0-000bac2be

package/dist/api/api/aiApi.d.ts

@@ -0,0 +1,251 @@
+import { AnprQueryParams, AnprEvent, EventCountRequestPayload, EventCountResponsePayload, EventsExportRequestParameters, GateReportROI, PaginatedItems, GateReportVerifiedDay, ProjectExid, CameraExid, AnprCountsQueryParams, AnprCount, AnprBasedGateReportExportRequestParams, GateReportResponsePayload, GatReportRequestPayload, VerifiedDaysQueryParams, VerifyDayUpdateRequestPayload, ProcessedDaysQueryParams, RoisQueryParams, GateReportRoiRequestPayload, SegmentsSimilaritySearchParams, DetectionsFilters, TrackingsByLabel, SegmentsByLabel, DetectionsCountsParams, DetectionsPresenceByLabel, SmartSearchBackendQueryPayload, SavedQuery, DateType, DetectionsRequestParams, DetectionsGroup, DetectionsCountsByPeriod, ObservationEvent, ObservationEventsQueryParams, ObservationEventsCountsQueryParams, ObservationEventsExportQueryParams, ObservationApprovalUpdateResponse, ObservationEventCount, ObservationType, DetectionsExportRequestParams, SegmentsFilters, DownloadFileType, SmartSearchBackendQuery, SmartSearchHeatmapData, SmartSearchOperatorType, DetectionLabel, SmartSearchResponse, SmartSearchRequestPayload, LegacyAnprExportParams, AnprBulkUpdateRequestPayload, AnprUpdateRequestPayload, SmartSearchQueriesRequestPayload, _360FloorId, CreateCoolifyAppRequestPayload, RegisterCoolifyAppResponsePayload, SaveCoolifyAppRequestPayload, SegmentsCountsParams, SegmentsPresenceResponse, AiPrompt, AiPromptCreatePayload, AiPromptCreateResponse, AiPromptDeleteResponse, AiPromptListResponse, AiPromptQueryParams, AiPromptUpdatePayload, AiPromptUpdateResponse, AiSubpromptCreatePayload, AiObservationType, AiObservationTypeCreatePayload, AiObservationTypeCreateResponse, AiObservationTypeDeleteResponse, AiObservationTypeListResponse, AiObservationTypeQueryParams, AiObservationTypeUpdatePayload, AiObservationTypeUpdateResponse, ObservationConfig, UpsertObservationConfigPayload, AiApiKey, AiApiKeyCreatePayload, AiApiKeyCreateResponse, AiApiKeyDeleteResponse, AiApiKeyQueryParams, AiApiKeyUpdatePayload, AiApiKeyUpdateResponse, APIEnvelope, AppActionResponse, AppRuntimeState, CoolifyProjectOption, CoolifyServerOption, CreateGateReportAppPayload, CreateGateReportAppResponse, GateReportAppEvents, GateReportAppsQueryParams, GateReportManagedApp, UpdateGateReportAppPayload, CreateSiteAnalyticsAppPayload, CreateSiteAnalyticsAppResponse, DeleteSiteAnalyticsAppResponse, ModelOption, SiteAnalyticsManagedApp, SiteAnalyticsManagementListParams, UpdateSiteAnalyticsAppPayload, ObservationEventQueryParams, ObservationEventListResponse, ObservationModelOption, ObservationEventReviewPayload, ObservationEventReviewResponse, Walk360Activity, Walk360Config, Walk360ConfigSummary, Walk360ProcessedSession, Walk360WorkerAction } from "@evercam/api/types";
+import type { AxiosPromise, AxiosRequestConfig } from "axios";
+export declare const getAiApiUrl: () => string;
+export declare const getAiApiUrlV2: () => string;
+export declare const AiApi: {
+    anpr: {
+        exportAnprLegacyEvents(projectExid: ProjectExid, params: LegacyAnprExportParams): AxiosPromise<any>;
+        getAnprEvents(projectExid: ProjectExid, params: AnprQueryParams, extraParams?: AxiosRequestConfig): Promise<PaginatedItems<AnprEvent>>;
+        getAnprCounts(projectExid: ProjectExid, payload: AnprCountsQueryParams, extraParams?: AxiosRequestConfig): Promise<AnprCount[]>;
+        updateAnprEvent(anprEventId: string, payload: AnprUpdateRequestPayload): Promise<import("axios").AxiosResponse<any, any>>;
+        bulkUpdateAnprRecords(payload: AnprBulkUpdateRequestPayload): Promise<void>;
+        exportAnprEvents(projectExid: string, params: AnprBasedGateReportExportRequestParams): AxiosPromise<string>;
+    };
+    gateReport: {
+        exportEvents(projectExid: string, params: EventsExportRequestParameters): AxiosPromise<any>;
+        exportEventsProgress(projectExid: string, params: {
+            exportDate: string;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        generateAnprThumbnail(cameraExid: CameraExid, captureTime: string): Promise<import("axios").AxiosResponse<any, any>>;
+        getVerifiedDays(projectExid: ProjectExid, params: Partial<VerifiedDaysQueryParams>, extraParams?: {}): Promise<PaginatedItems<GateReportVerifiedDay>>;
+        verifyDay(params: VerifyDayUpdateRequestPayload): Promise<import("axios").AxiosResponse<any, any>>;
+        getDailyStatus(projectExid: string, params?: Partial<ProcessedDaysQueryParams>): Promise<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>>;
+    };
+    roi: {
+        getROIs(projectExid: string, params?: Partial<RoisQueryParams>): Promise<GateReportROI[]>;
+        listROIs(params?: Partial<RoisQueryParams>): Promise<GateReportROI[]>;
+        createROI(params: Omit<GateReportRoiRequestPayload, "id"> & {
+            createdBy?: string;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        updateROI({ updatedBy, id, ...params }: Partial<GateReportRoiRequestPayload> & {
+            updatedBy?: string;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        deleteROI({ id, updatedBy }: {
+            id: number;
+            updatedBy: string;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    detections: {
+        getDetectionsCounts({ projectExid, ...params }: Partial<DetectionsRequestParams>, extraParams?: AxiosRequestConfig): Promise<DetectionsCountsByPeriod>;
+        getDetectionsByTimestamp({ projectExid, ...params }: DetectionsRequestParams, extraParams?: AxiosRequestConfig): Promise<PaginatedItems<DetectionsGroup>>;
+        getSimilarSegmentsInTimeIntervals({ cameraExid, iouThreshold, ...params }: SegmentsSimilaritySearchParams): Promise<import("axios").AxiosResponse<any, any>>;
+        getGroupedTrackings(projectExid: ProjectExid, params: DetectionsFilters): Promise<TrackingsByLabel>;
+        getSegmentsMasks(cameraExid: CameraExid, params: SegmentsFilters): Promise<{
+            segments: SegmentsByLabel;
+        }>;
+        getSegmentsPresenceDateIntervals({ cameraExid, ...params }: SegmentsCountsParams): Promise<SegmentsPresenceResponse>;
+        getDetectionsPresenceDateIntervals({ projectExid, ...params }: DetectionsCountsParams): Promise<DetectionsPresenceByLabel>;
+        requestExport({ projectExid, ...params }: DetectionsExportRequestParams): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    observations: {
+        getEvents({ projectExid, ...params }: {
+            projectExid: ProjectExid;
+        } & ObservationEventsQueryParams, extraParams?: AxiosRequestConfig): Promise<PaginatedItems<ObservationEvent>>;
+        getCounts({ projectExid, ...params }: {
+            projectExid: ProjectExid;
+        } & ObservationEventsCountsQueryParams, extraParams?: AxiosRequestConfig): Promise<APIEnvelope<ObservationEventCount[]>>;
+        getConfiguredTypes(projectExid: ProjectExid, extraParams?: AxiosRequestConfig): Promise<APIEnvelope<ObservationType[]>>;
+        exportEvents({ projectExid, ...params }: {
+            projectExid: ProjectExid;
+        } & ObservationEventsExportQueryParams, extraParams?: AxiosRequestConfig): Promise<Blob | {
+            message: string;
+        }>;
+        updateEventApproval({ projectExid, eventId, isApproved, }: {
+            projectExid: ProjectExid;
+            eventId: number;
+            isApproved: boolean | null;
+        }): Promise<ObservationApprovalUpdateResponse>;
+    };
+    siteAnalytics: {
+        smartSearchAll(projectExid: ProjectExid, params: SmartSearchRequestPayload): Promise<SmartSearchResponse>;
+        smartSearchFirstLastSeen(projectExid: ProjectExid, params: SmartSearchRequestPayload): Promise<SmartSearchResponse>;
+        saveQuery({ projectExid, cameraExid, payload, }: {
+            projectExid: ProjectExid;
+            cameraExid: CameraExid | _360FloorId;
+            payload: SmartSearchBackendQueryPayload;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        getQueries(projectExid: ProjectExid, params: SmartSearchQueriesRequestPayload): Promise<SavedQuery[]>;
+        getQueryById(projectExid: ProjectExid, cameraExid: CameraExid, queryId: number): Promise<SmartSearchBackendQueryPayload>;
+        updateQuery({ projectExid, cameraExid, queryId, payload, }: {
+            projectExid: ProjectExid;
+            cameraExid: CameraExid;
+            queryId: number;
+            payload: Partial<SavedQuery>;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        deleteQuery({ projectExid, cameraExid, queryId, }: {
+            projectExid: ProjectExid;
+            cameraExid: CameraExid;
+            queryId: number;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        exportResultsData({ projectExid, cameraExids, fromDate, toDate, query, fileType, directDownload, payload, limit, page, }: {
+            projectExid: ProjectExid;
+            cameraExids: CameraExid[];
+            fromDate?: DateType;
+            toDate?: DateType;
+            query: string;
+            fileType: DownloadFileType;
+            directDownload?: boolean;
+            payload: SmartSearchBackendQuery;
+            limit: number;
+            page: number;
+        }): Promise<any>;
+        getDetectionsHeatmapData(projectExid: ProjectExid, params: {
+            cameraExid: CameraExid;
+            fromDate: DateType | string | null;
+            toDate: DateType | string | null;
+            labels: DetectionLabel[];
+            operator?: SmartSearchOperatorType;
+        }): Promise<SmartSearchHeatmapData[]>;
+    };
+    siteAnalyticsManagement: {
+        listApps(params?: SiteAnalyticsManagementListParams): Promise<PaginatedItems<SiteAnalyticsManagedApp>>;
+        createApp(payload: CreateSiteAnalyticsAppPayload): Promise<CreateSiteAnalyticsAppResponse>;
+        getApp(projectExid: ProjectExid, cameraExid: CameraExid): Promise<APIEnvelope<SiteAnalyticsManagedApp>>;
+        updateApp(projectExid: ProjectExid, cameraExid: CameraExid, payload: UpdateSiteAnalyticsAppPayload): Promise<APIEnvelope<SiteAnalyticsManagedApp>>;
+        deleteApp(projectExid: ProjectExid, cameraExid: CameraExid): Promise<DeleteSiteAnalyticsAppResponse>;
+        setAppState(projectExid: ProjectExid, cameraExid: CameraExid, state: AppRuntimeState): Promise<APIEnvelope<AppActionResponse>>;
+        listCoolifyServers(): Promise<APIEnvelope<CoolifyServerOption[]>>;
+        listModelVersions(): Promise<APIEnvelope<ModelOption[]>>;
+    };
+    coolify: {
+        getCoolifyServers(): Promise<import("axios").AxiosResponse<any, any>>;
+        createAppOnCoolify({ projectExid, cameraExid, payload, }: {
+            projectExid: ProjectExid;
+            cameraExid: CameraExid;
+            payload: CreateCoolifyAppRequestPayload;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        registerCoolifyApp({ projectExid, cameraExid, payload, }: {
+            projectExid: ProjectExid;
+            cameraExid: CameraExid;
+            payload: SaveCoolifyAppRequestPayload;
+        }): Promise<RegisterCoolifyAppResponsePayload>;
+        updateApp({ appUuid, appId, payload, cameraExid, projectExid, }: {
+            projectExid: string;
+            cameraExid: string;
+            appId: string;
+            appUuid: string;
+            payload: Partial<SaveCoolifyAppRequestPayload>;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        deleteApp({ appUuid, appId, cameraExid, projectExid, }: {
+            projectExid: string;
+            cameraExid: string;
+            appId: string;
+            appUuid: string;
+        }): Promise<import("axios").AxiosResponse<any, any>>;
+        startService(serviceId: string): Promise<import("axios").AxiosResponse<any, any>>;
+        pauseService(serviceId: string): Promise<import("axios").AxiosResponse<any, any>>;
+        restartService(serviceId: string): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    fovChanges: {
+        getCameraFovChanges(cameraExid: string, extraConfig?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    prompts: {
+        list(params?: AiPromptQueryParams): Promise<AiPromptListResponse>;
+        get(promptId: number): Promise<AiPrompt>;
+        create(payload: AiPromptCreatePayload): Promise<AiPromptCreateResponse>;
+        update(promptId: number, payload: AiPromptUpdatePayload): Promise<AiPromptUpdateResponse>;
+        delete(promptId: number): Promise<AiPromptDeleteResponse>;
+        listSubprompts(promptId: number): Promise<AiPrompt[]>;
+        createSubprompt(promptId: number, payload: AiSubpromptCreatePayload): Promise<AiPromptCreateResponse>;
+    };
+    observations360: {
+        getWalkConfig(projectExid: string): Promise<{
+            data: Walk360Config;
+        }>;
+        saveWalkConfig(projectExid: string, payload: {
+            enabled: boolean;
+            startDate: string | null;
+            activities: Walk360Activity[];
+            maxParallelWalks?: number;
+            visionProvider?: string;
+            coolifyServerUuid?: string | null;
+        }): Promise<{
+            data: Walk360Config;
+        }>;
+        listProcessedWalks(projectExid: string): Promise<{
+            data: Walk360ProcessedSession[];
+        }>;
+        listWalkTypes(): Promise<{
+            data: AiObservationType[];
+        }>;
+        listConfigs(): Promise<{
+            data: Walk360ConfigSummary[];
+        }>;
+        deleteWalkConfig(projectExid: string): Promise<{
+            deleted: boolean;
+        }>;
+        setWorkerState(projectExid: string, state: AppRuntimeState): Promise<{
+            data: Walk360WorkerAction;
+        }>;
+    };
+    observationTypes: {
+        list(params?: AiObservationTypeQueryParams): Promise<AiObservationTypeListResponse>;
+        get(observationTypeId: number): Promise<AiObservationType>;
+        create(payload: AiObservationTypeCreatePayload): Promise<AiObservationTypeCreateResponse>;
+        update(observationTypeId: number, payload: AiObservationTypeUpdatePayload): Promise<AiObservationTypeUpdateResponse>;
+        delete(observationTypeId: number): Promise<AiObservationTypeDeleteResponse>;
+    };
+    siteAnalyticsObservations: {
+        getConfig(cameraExid: string): Promise<ObservationConfig>;
+        upsertConfig(cameraExid: string, payload: UpsertObservationConfigPayload): Promise<ObservationConfig>;
+        deleteConfig(cameraExid: string): Promise<{
+            deleted: boolean;
+            count: number;
+            message: string;
+        }>;
+    };
+    apiKeys: {
+        list(params?: AiApiKeyQueryParams): Promise<AiApiKey[]>;
+        purposes(): Promise<string[]>;
+        get(keyId: number): Promise<AiApiKey>;
+        create(payload: AiApiKeyCreatePayload): Promise<AiApiKeyCreateResponse>;
+        update(keyId: number, payload: AiApiKeyUpdatePayload): Promise<AiApiKeyUpdateResponse>;
+        delete(keyId: number, revoke?: boolean): Promise<AiApiKeyDeleteResponse>;
+    };
+    observationEvents: {
+        list(params?: ObservationEventQueryParams): Promise<ObservationEventListResponse>;
+        frameUrl(eventId: number, options?: {
+            thumbnail?: boolean;
+            token?: string | null;
+        }): string;
+        projects(): Promise<{
+            data: Array<{
+                projectExid: string;
+                total: number;
+            }>;
+        }>;
+        models(): Promise<APIEnvelope<ObservationModelOption[]>>;
+        review(projectExid: string, eventId: number, payload: ObservationEventReviewPayload): Promise<ObservationEventReviewResponse>;
+    };
+    gateReportManagement: {
+        listApps(params?: GateReportAppsQueryParams): Promise<PaginatedItems<GateReportManagedApp>>;
+        getApp(projectExid: ProjectExid, cameraExid: CameraExid): Promise<APIEnvelope<GateReportManagedApp>>;
+        listAppEvents(projectExid?: ProjectExid): Promise<APIEnvelope<GateReportAppEvents[]>>;
+        createApp(payload: CreateGateReportAppPayload): Promise<CreateGateReportAppResponse>;
+        updateApp(projectExid: ProjectExid, cameraExid: CameraExid, payload: UpdateGateReportAppPayload): Promise<APIEnvelope<GateReportManagedApp>>;
+        deleteApp(projectExid: ProjectExid, cameraExid: CameraExid): Promise<{
+            deleted: boolean;
+            count: number;
+            message: string;
+        }>;
+        setAppState(projectExid: ProjectExid, cameraExid: CameraExid, state: AppRuntimeState): Promise<APIEnvelope<AppActionResponse>>;
+        listCoolifyProjects(): Promise<APIEnvelope<CoolifyProjectOption[]>>;
+        listCoolifyServers(): Promise<APIEnvelope<CoolifyServerOption[]>>;
+        listImageTags(): Promise<APIEnvelope<string[]>>;
+    };
+};

package/dist/api/api/authzApi.d.ts

@@ -0,0 +1,40 @@
+import type { AuthzRoleUser, AuthzScope, AuthzScopeCreatePayload, AuthzScopeUpdatePayload, AuthzUserRolesResponse, PaginatedItems, ProjectExid, ProjectResourceRole, ProjectRoleRequestPayload, Role, RoleAssignmentLogBatch, RoleAssignmentLogsParams, RoleResourceType } from "@evercam/api/types";
+import type { AxiosRequestConfig } from "axios";
+export declare const AuthzApi: {
+    roles: {
+        get(params?: AxiosRequestConfig & {
+            params?: {
+                scope?: string;
+            };
+        }): Promise<{
+            total: number;
+            items: Role[];
+        }>;
+        getRoleDetails(id: number): Promise<Role>;
+        createRole(params: Partial<Role> & Pick<Role, "name">): Promise<Role>;
+        updateRole(id: number, params: Partial<Role>): Promise<Role>;
+        deleteRole(id: number): Promise<void>;
+        addPermission(id: number, action: string): Promise<void>;
+        deletePermission(id: number, action: string): Promise<void>;
+        getRoleUsers(id: number): Promise<AuthzRoleUser[]>;
+        assignUsers(roleId: number, emails: Array<string>, resourceId?: string): Promise<void>;
+        getAssignments(params: AxiosRequestConfig & {
+            params: Partial<RoleAssignmentLogsParams>;
+        }): Promise<PaginatedItems<RoleAssignmentLogBatch>>;
+        getUserRoles(projectExid?: ProjectExid, resourceType?: RoleResourceType): Promise<AuthzUserRolesResponse>;
+    };
+    projectRoles: {
+        get(projectExid: ProjectExid): Promise<{
+            roles: Role[];
+        }>;
+        create(projectExid: ProjectExid, params: ProjectRoleRequestPayload): Promise<ProjectResourceRole>;
+        update(projectExid: ProjectExid, roleId: number, params: ProjectRoleRequestPayload): Promise<ProjectResourceRole>;
+        delete(projectExid: ProjectExid, roleId: number): Promise<import("axios").AxiosResponse<any, any>>;
+    };
+    scopes: {
+        get(): Promise<AuthzScope[]>;
+        create(params: AuthzScopeCreatePayload): Promise<AuthzScope>;
+        delete(id: number): Promise<void>;
+        update(id: number, params: AuthzScopeUpdatePayload): Promise<AuthzScope>;
+    };
+};

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

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

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

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

package/dist/api/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/api/client/interceptors.d.ts

@@ -0,0 +1,10 @@
+import { AxiosDefaults, type AxiosError, type AxiosRequestConfig, type AxiosResponse } from "axios";
+import { type AxiosEnvironment } from "@evercam/api/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>>;

package/dist/api/api/client/swr/Swr.d.ts

@@ -0,0 +1,14 @@
+import { AxiosRequestConfig } from "axios";
+import { ExtendedAxiosInstance, ResponseValue } from "@evercam/api/types";
+export declare class Swr {
+    private axiosInstance;
+    private store;
+    constructor({ key, axiosInstance, }: {
+        key: string;
+        axiosInstance: ExtendedAxiosInstance;
+    });
+    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<ResponseValue<T>>;
+    private getCachedValue;
+    private getFreshValue;
+    clear(): Promise<void>;
+}

package/dist/api/api/client/swr/SwrStore.d.ts

@@ -0,0 +1,10 @@
+import { AxiosRequestConfig } from "axios";
+export declare class SwrStore {
+    private prefix;
+    constructor(prefix: string);
+    generateKey(config: AxiosRequestConfig): string;
+    get(key: string): Promise<any>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}