@vireocodedev/infrastructure

export declare class AppOfflineError extends Error {
    constructor();
}

export declare class AppOfflineQueuedError extends Error {
    constructor();
}

export declare abstract class AxiosHttpClient {
    private readonly base;
    private readonly client;
    private readonly resolveEndpoint;
    constructor(base: string, client: AxiosInstance, resolveEndpoint?: HttpEndpointResolver);
    protected httpGet<TSchema extends z.ZodTypeAny = z.ZodUnknown>(schema?: TSchema): (url: string, config?: AxiosRequestConfig) => Promise<z.infer<TSchema>>;
    protected httpGetBlob(): (url: string, config?: AxiosRequestConfig) => Promise<Blob>;
    protected httpGetPageable<TSchema extends z.ZodTypeAny = z.ZodUnknown>(schema?: TSchema): (url: string, pageable: PageableParams, config?: AxiosRequestConfig) => Promise<PageableResponse<z.infer<TSchema>>>;
    protected httpPost<TSchema extends z.ZodTypeAny = z.ZodUnknown>(schema?: TSchema): (url: string, data?: unknown, config?: AxiosRequestConfig) => Promise<z.infer<TSchema>>;
    protected httpPut<TSchema extends z.ZodTypeAny = z.ZodUnknown>(schema?: TSchema): (url: string, data?: unknown, config?: AxiosRequestConfig) => Promise<z.infer<TSchema>>;
    protected httpPatch<TSchema extends z.ZodTypeAny = z.ZodUnknown>(schema?: TSchema): (url: string, data?: unknown, config?: AxiosRequestConfig) => Promise<z.infer<TSchema>>;
    protected httpDelete<TSchema extends z.ZodTypeAny = z.ZodUnknown>(schema?: TSchema): (url: string, config?: AxiosRequestConfig) => Promise<z.infer<TSchema>>;
    private doGet;
    private doGetPageable;
    private doPost;
    private doPut;
    private doPatch;
    private doDelete;
}

export type ConnectivityRuntimeAdapter = {
    readBrowserOnline: () => boolean;
    subscribeBrowserOnline: (listener: (online: boolean) => void) => () => void;
    scheduleRepeating: (callback: () => void, intervalMs: number) => () => void;
};

export type ConnectivitySnapshot = {
    online: boolean;
    heartbeatEnabled: boolean;
    heartbeatConnected: boolean;
    syncInProgress: boolean;
    lastHeartbeatAt: number | null;
};

export type ConnectivityStateOptions = {
    initialBrowserOnline: boolean;
    heartbeatStaleAfterMs: number;
    heartbeatBootstrapAssumeOnlineMs: number;
    runtimeIntervalMs?: number;
    now?: () => number;
};

export type CreateModeAwareApiOptions<TOnlineApi extends Record<string, unknown>, TOfflineApi extends Partial<{
    [TModuleKey in keyof TOnlineApi]: unknown;
}>> = {
    onlineApi: TOnlineApi;
    offlineApi: TOfflineApi;
    readOnline: () => boolean;
    assertCanInvoke?: (context: ModeAwareApiInvocationContext) => void;
    isOfflineTransactional?: (offlineMethod: unknown, context: ModeAwareApiInvocationContext) => boolean;
    isOfflineFallbackError?: (error: unknown, context: ModeAwareApiInvocationContext) => boolean;
    createNoFallbackError?: (context: ModeAwareApiInvocationContext) => Error;
    now?: () => number;
    onInvokeSuccess?: (event: ModeAwareApiInvocationEvent) => void;
    onInvokeError?: (event: ModeAwareApiInvocationEvent, error: unknown) => void;
};

export type HttpEndpointResolver = (base: string, ...segments: (number | string)[]) => string;

export type ModeAwareApiInvocationContext = {
    moduleKey: string;
    methodName: string;
    methodLabel: string;
    online: boolean;
};

export type ModeAwareApiInvocationEvent = ModeAwareApiInvocationContext & {
    mode: ModeAwareApiMode;
    durationMs: number;
};

export type ModeAwareApiMode = "offline" | "online";

export declare class OfflineModeNotSupportedError extends Error {
    constructor(operation: string);
}

export type PageableParams = {
    page: number;
    rowsPerPage: number;
    sortBy: string;
    sortDirection: "asc" | "desc";
};

export type PageableResponse<T> = {
    content: T[];
    number: number;
    size: number;
    totalElements: number;
    totalPages: number;
};

export type PagedSearchRequest<TEntity, TFilters extends SearchableFilters> = {
    client: Pick<AxiosInstance, "post">;
    endpointName: string;
    schema: z.ZodType<TEntity>;
    pageable: PageableParams;
    filters: TFilters;
    config?: AxiosRequestConfig;
    resolveEndpoint?: HttpEndpointResolver;
};

export type PersistentSignal<TData extends Record<string, unknown>, TKey extends keyof TData> = {
    signal: Signal<TData[TKey]>;
    setLocal: (value: TData[TKey]) => void;
};

export type SanitizedAxiosError = {
    code?: string;
    message: string;
    method?: string;
    name: string;
    path?: string;
    status?: number;
};

export type SearchableFilters = {
    searchText: string;
    queryFiltersJson?: string | null;
};

export type SessionExpiryChannel = {
    beginManualLogout: () => void;
    cancelManualLogout: () => void;
    getState: () => SessionExpiryState;
    notifySessionExpired: () => boolean;
    reset: () => void;
    subscribe: (listener: () => void) => () => void;
};

export type SessionExpiryChannelOptions = {
    onListenerError?: (error: unknown) => void;
};

export type SessionExpiryState = Readonly<{
    manualLogoutPending: boolean;
    notificationPending: boolean;
}>;

export declare function createConnectivityState({ initialBrowserOnline, heartbeatStaleAfterMs, heartbeatBootstrapAssumeOnlineMs, runtimeIntervalMs, now, }: ConnectivityStateOptions): {
    sigOnline: import('@preact/signals-core').ReadonlySignal<boolean>;
    sigSnapshot: import('@preact/signals-core').ReadonlySignal<ConnectivitySnapshot>;
    sigReconnectRequestTick: import('@preact/signals-core').Signal<number>;
    setHeartbeatEnabled: (enabled: boolean) => void;
    markHeartbeatConnected: () => void;
    markHeartbeatDisconnected: () => void;
    markHeartbeatReceived: (syncInProgress: boolean) => void;
    markBackendUnavailable: () => void;
    markBackendAvailable: () => void;
    startRuntime: (adapter: ConnectivityRuntimeAdapter) => () => void;
};

export declare function createModeAwareApi<TOnlineApi extends Record<string, unknown>, TOfflineApi extends Partial<{
    [TModuleKey in keyof TOnlineApi]: unknown;
}>>({ onlineApi, offlineApi, readOnline, assertCanInvoke, isOfflineTransactional, isOfflineFallbackError, createNoFallbackError, now, onInvokeSuccess, onInvokeError, }: CreateModeAwareApiOptions<TOnlineApi, TOfflineApi>): TOnlineApi;

export declare function createPageableResponseSchema<TSchema extends z.ZodTypeAny>(contentSchema: TSchema): z.ZodObject<{
    content: z.ZodArray<TSchema>;
    number: z.ZodNumber;
    size: z.ZodNumber;
    totalElements: z.ZodNumber;
    totalPages: z.ZodNumber;
}, z.core.$strip>;

export declare function createPersistentSignal<TData extends Record<string, unknown>, TKey extends keyof TData>(storage: Storage<TData>, key: TKey): PersistentSignal<TData, TKey>;

Creates an isolated session-expiry coordination channel. Applications own the instance and decide how a notification changes routing or authentication state. Infrastructure only deduplicates notifications and suppresses expiry handling while an intentional logout is pending.

/**
 * Creates an isolated session-expiry coordination channel.
 *
 * Applications own the instance and decide how a notification changes routing
 * or authentication state. Infrastructure only deduplicates notifications and
 * suppresses expiry handling while an intentional logout is pending.
 */
export declare function createSessionExpiryChannel(options?: SessionExpiryChannelOptions): SessionExpiryChannel;

export declare function emptyPageableResponse<T>(pageable: PageableParams): PageableResponse<T>;

export declare function getAppOnlineStatus(): boolean;

export declare function getAxiosRequestPath(error: AxiosError): string | undefined;

export declare function getTransactionalMetadata(value: unknown): boolean;

export declare function isAppOfflineError(error: unknown): error is AppOfflineError;

export declare function isRequestCanceled(error: unknown): boolean;

export declare function normalizePageableResponse<T>(response: PageableResponse<T>, fallbackPageable: PageableParams): PageableResponse<T>;

export declare function parseHttpResponse<TSchema extends z.ZodTypeAny>(schema: TSchema, data: unknown): z.infer<TSchema>;

export declare function parseQueryFilterRequest(filtersJson: string | null): unknown | undefined;

export declare function postPagedSearch<TEntity, TFilters extends SearchableFilters>({ client, endpointName, schema, pageable, filters, config, resolveEndpoint, }: PagedSearchRequest<TEntity, TFilters>): Promise<PageableResponse<TEntity>>;

export declare function resolveHttpEndpoint(base: string, ...segments: (number | string)[]): string;

export declare function sanitizeAxiosError(error: AxiosError): SanitizedAxiosError;

export declare function sortLocalResultsByAccessor<T>(items: T[], sortDirection: string | undefined, getValue: (item: T) => number | string): T[];

export declare function subscribeToAppNetworkStatus(onStoreChange: () => void): () => void;

export declare function transactional<TThis, TArgs extends unknown[], TResult>(): (originalMethod: AsyncMethod<TThis, TArgs, TResult>, context: ClassMethodDecoratorContext<TThis, AsyncMethod<TThis, TArgs, TResult>>) => AsyncMethod<TThis, TArgs, TResult>;