@web-ts-toolkit/access-router-client 0.3.0

package/index.d.mts

@@ -0,0 +1,552 @@
+import * as axios from 'axios';
+import { AxiosRequestConfig, AxiosInstance, AxiosResponse, AxiosHeaders } from 'axios';
+
+declare class Model<T extends Document, TData extends Partial<T> = T> {
+    private _data;
+    private _snapshot;
+    private readonly _service;
+    private modifiedPaths;
+    constructor(data: TData, adapter: ModelService<T>);
+    static create<T, TData extends Partial<T> = T>(data: TData, adapter: ModelService<T>): Model<T, TData> & TData;
+    save(reqConfig?: AxiosRequestConfig): Promise<any>;
+    isDirty(path?: keyof TData | string): boolean;
+    markModified(path: keyof TData | string): this;
+    get<TKey extends keyof TData>(path: TKey): TData[TKey];
+    get(path: string): unknown;
+    set<TKey extends keyof TData>(path: TKey, value: TData[TKey]): this;
+    set(path: string, value: unknown): this;
+    assign(partial: Partial<TData>): this;
+    reset(): this;
+    toObject(): TData;
+    toJSON(): TData;
+    private updateModel;
+    private replaceData;
+    private initializeDirtyState;
+    private prepareData;
+    private defineHiddenDataProp;
+    private defineHiddenAdapterProp;
+    private definePublicDataProps;
+    private trackModified;
+    private normalizePath;
+}
+
+interface SubQueryOptions {
+    path?: string;
+    compact?: boolean;
+}
+interface ListArgs {
+    skip?: number;
+    limit?: number;
+    page?: number;
+    pageSize?: number;
+}
+interface ListOptions {
+    skim?: boolean;
+    includePermissions?: boolean;
+    includeCount?: boolean;
+    includeExtraHeaders?: boolean;
+    ignoreCache?: boolean;
+    sq?: SubQueryOptions;
+}
+interface ListAdvancedArgs<TSelect extends Projection = Projection> {
+    select?: TSelect;
+    populate?: Populate[] | Populate | string;
+    include?: Include | Include[];
+    sort?: Sort;
+    skip?: string | number;
+    limit?: string | number;
+    page?: string | number;
+    pageSize?: string | number;
+    tasks?: Task | Task[];
+}
+interface ListAdvancedOptions {
+    skim?: boolean;
+    includePermissions?: boolean;
+    includeCount?: boolean;
+    includeExtraHeaders?: boolean;
+    ignoreCache?: boolean;
+    populateAccess?: PopulateAccess;
+    sq?: SubQueryOptions;
+}
+interface ReadOptions {
+    includePermissions?: boolean;
+    tryList?: boolean;
+    ignoreCache?: boolean;
+    sq?: SubQueryOptions;
+}
+interface ReadAdvancedArgs<TSelect extends Projection = Projection> {
+    select?: TSelect;
+    sort?: Sort;
+    populate?: Populate[] | Populate | string;
+    include?: Include | Include[];
+    tasks?: Task | Task[];
+}
+interface ReadAdvancedOptions {
+    skim?: boolean;
+    includePermissions?: boolean;
+    tryList?: boolean;
+    populateAccess?: PopulateAccess;
+    ignoreCache?: boolean;
+    sq?: SubQueryOptions;
+}
+interface CreateOptions {
+    includePermissions?: boolean;
+}
+interface CreateAdvancedArgs<TSelect extends Projection = Projection> {
+    select?: TSelect;
+    populate?: Populate[] | Populate | string;
+    tasks?: Task | Task[];
+}
+interface CreateAdvancedOptions {
+    includePermissions?: boolean;
+    populateAccess?: PopulateAccess;
+}
+interface UpdateOptions {
+    returningAll?: boolean;
+}
+interface UpdateAdvancedArgs<TSelect extends Projection = Projection> {
+    select?: TSelect;
+    populate?: Populate[] | Populate | string;
+    tasks?: Task | Task[];
+}
+interface UpdateAdvancedOptions {
+    returningAll?: boolean;
+    includePermissions?: boolean;
+    populateAccess?: PopulateAccess;
+}
+type UpsertOptions = UpdateOptions;
+type UpsertAdvancedArgs<TSelect extends Projection = Projection> = UpdateAdvancedArgs<TSelect>;
+type UpsertAdvancedOptions = UpdateAdvancedOptions;
+interface Defaults {
+    listArgs?: ListArgs;
+    listOptions?: ListOptions;
+    listAdvancedArgs?: ListAdvancedArgs;
+    listAdvancedOptions?: ListAdvancedOptions;
+    readOptions?: ReadOptions;
+    readAdvancedArgs?: ReadAdvancedArgs;
+    readAdvancedOptions?: ReadAdvancedOptions;
+    createOptions?: CreateOptions;
+    createAdvancedArgs?: CreateAdvancedArgs;
+    createAdvancedOptions?: CreateAdvancedOptions;
+    updateOptions?: UpdateOptions;
+    updateAdvancedArgs?: UpdateAdvancedArgs;
+    updateAdvancedOptions?: UpdateAdvancedOptions;
+    upsertOptions?: UpsertOptions;
+    upsertAdvancedArgs?: UpsertAdvancedArgs;
+    upsertAdvancedOptions?: UpsertAdvancedOptions;
+}
+interface DataListArgs {
+    skip?: number;
+    limit?: number;
+    page?: number;
+    pageSize?: number;
+}
+interface DataListOptions {
+    includePermissions?: boolean;
+    includeCount?: boolean;
+    includeExtraHeaders?: boolean;
+    ignoreCache?: boolean;
+}
+interface DataListAdvancedArgs<TSelect extends Projection = Projection> {
+    select?: TSelect;
+    sort?: Sort;
+    skip?: string | number;
+    limit?: string | number;
+    page?: string | number;
+    pageSize?: string | number;
+}
+interface DataListAdvancedOptions {
+    includePermissions?: boolean;
+    includeCount?: boolean;
+    includeExtraHeaders?: boolean;
+    ignoreCache?: boolean;
+}
+interface DataReadOptions {
+    includePermissions?: boolean;
+    ignoreCache?: boolean;
+}
+interface DataReadAdvancedArgs<TSelect extends Projection = Projection> {
+    select?: TSelect;
+    ignoreCache?: boolean;
+}
+interface DataReadAdvancedOptions {
+    includePermissions?: boolean;
+    ignoreCache?: boolean;
+}
+interface DataDefaults {
+    listArgs?: DataListArgs;
+    listOptions?: DataListOptions;
+    listAdvancedArgs?: DataListAdvancedArgs;
+    listAdvancedOptions?: DataListAdvancedOptions;
+    readOptions?: DataReadOptions;
+    readAdvancedArgs?: DataReadAdvancedArgs;
+    readAdvancedOptions?: DataReadAdvancedOptions;
+}
+interface AdditionalReqConfig {
+    throwOnError?: boolean;
+}
+
+type AnyArray<T> = T[] | ReadonlyArray<T>;
+type Unpacked<T> = T extends (infer U)[] ? U : T extends ReadonlyArray<infer U> ? U : T;
+type ApplyBasicQueryCasting<T> = T | T[] | (T extends (infer U)[] ? U : unknown) | unknown;
+type Condition<T> = ApplyBasicQueryCasting<T> | QuerySelector<ApplyBasicQueryCasting<T>>;
+type _FilterQuery<T> = {
+    [P in keyof T]?: Condition<T[P]>;
+} & RootQuerySelector<T>;
+type RootQuerySelector<T> = {
+    /** @see https://www.mongodb.com/docs/manual/reference/operator/query/and/#op._S_and */
+    $and?: Array<_FilterQuery<T>>;
+    /** @see https://www.mongodb.com/docs/manual/reference/operator/query/nor/#op._S_nor */
+    $nor?: Array<_FilterQuery<T>>;
+    /** @see https://www.mongodb.com/docs/manual/reference/operator/query/or/#op._S_or */
+    $or?: Array<_FilterQuery<T>>;
+    /** @see https://www.mongodb.com/docs/manual/reference/operator/query/text */
+    $text?: {
+        $search: string;
+        $language?: string;
+        $caseSensitive?: boolean;
+        $diacriticSensitive?: boolean;
+    };
+    /** @see https://www.mongodb.com/docs/manual/reference/operator/query/where/#op._S_where */
+    $where?: string | ((...args: never[]) => unknown);
+    /** @see https://www.mongodb.com/docs/manual/reference/operator/query/comment/#op._S_comment */
+    $comment?: string;
+    [key: string]: unknown;
+};
+type QuerySelector<T> = {
+    $eq?: T;
+    $gt?: T;
+    $gte?: T;
+    $in?: [T] extends AnyArray<unknown> ? Unpacked<T>[] : T[];
+    $lt?: T;
+    $lte?: T;
+    $ne?: T;
+    $nin?: [T] extends AnyArray<unknown> ? Unpacked<T>[] : T[];
+    $not?: T extends string ? QuerySelector<T> | RegExp : QuerySelector<T>;
+    /**
+     * When `true`, `$exists` matches the documents that contain the field,
+     * including documents where the field value is null.
+     */
+    $exists?: boolean;
+    $type?: string | number;
+    $expr?: unknown;
+    $jsonSchema?: unknown;
+    $mod?: T extends number ? [number, number] : never;
+    $regex?: T extends string ? RegExp | string : never;
+    $options?: T extends string ? string : never;
+};
+
+type KeyValueProjection<TKey extends string = string> = Partial<Record<TKey, 1 | -1>>;
+type Projection = readonly string[] | string | KeyValueProjection;
+type SelectableKey<T> = Extract<keyof T, string>;
+type IsTuple<T extends readonly unknown[]> = number extends T['length'] ? false : true;
+type SelectedKeysFromProjectionArray<T, TSelect> = TSelect extends readonly (infer K)[] ? IsTuple<TSelect> extends true ? Extract<K, SelectableKey<T>> : never : never;
+type SelectedKeysFromProjectionString<T, TSelect> = TSelect extends string ? string extends TSelect ? never : Extract<TSelect, SelectableKey<T>> : never;
+type SelectedKeysFromProjectionObject<T, TSelect> = TSelect extends KeyValueProjection ? string extends keyof TSelect ? never : {
+    [K in keyof TSelect]-?: TSelect[K] extends 1 ? Extract<K, SelectableKey<T>> : never;
+}[keyof TSelect] : never;
+type SelectedKeys<T, TSelect> = SelectedKeysFromProjectionArray<T, TSelect> | SelectedKeysFromProjectionString<T, TSelect> | SelectedKeysFromProjectionObject<T, TSelect>;
+type SelectedShape<T, TSelect> = [SelectedKeys<T, TSelect>] extends [never] ? Partial<T> : Pick<T, SelectedKeys<T, TSelect>> & Partial<T>;
+type ResolvedSelectedShape<T, TSelect, TExplicit> = [TExplicit] extends [never] ? SelectedShape<T, TSelect> : TExplicit;
+type SortOrder = -1 | 1 | 'asc' | 'ascending' | 'desc' | 'descending';
+type Sort = string | {
+    [key: string]: SortOrder;
+} | [string, SortOrder][] | undefined | null;
+type FilterQuery<T> = _FilterQuery<T>;
+interface Include {
+    model: string;
+    op: 'list' | 'read' | 'count';
+    path: string;
+    localField: string;
+    foreignField: string;
+    filter?: FilterQuery<unknown>;
+    args?: Record<string, unknown>;
+    options?: Record<string, unknown>;
+}
+type PopulateAccess = 'list' | 'read';
+interface Populate {
+    path: string;
+    select?: Projection;
+    match?: Record<string, unknown> | null;
+    access?: PopulateAccess;
+}
+interface Document {
+    _id?: string;
+}
+interface Response<T1, T2 = T1> {
+    success: boolean;
+    raw: T1;
+    data: T2;
+    message: string;
+    status: number;
+    headers: Record<string, string>;
+}
+type ModelResponse<T, TData extends Partial<T> = T> = Response<TData, Model<T, TData> & TData>;
+type ArrayModelResponse<T, TData extends Partial<T> = T> = Response<TData[], (Model<T, TData> & TData)[]>;
+type ListModelResponse<T, TData extends Partial<T> = T> = ArrayModelResponse<T, TData> & {
+    totalCount: number;
+};
+interface Task {
+    type: string;
+    args: unknown;
+    options: Record<string, unknown>;
+}
+type RootModelOperation = 'new' | 'list' | 'read' | 'create' | 'update' | 'upsert' | 'delete' | 'distinct' | 'count' | 'subList' | 'subRead' | 'subCreate' | 'subUpdate' | 'subBulkUpdate' | 'subDelete';
+type RootDataOperation = 'list' | 'read';
+interface RootModelQueryMeta {
+    target: 'model';
+    name: string;
+    model: string;
+    op: RootModelOperation;
+    id?: string;
+    sub?: string;
+    subId?: string;
+    field?: string;
+    filter?: unknown;
+    data?: unknown;
+    args?: Record<string, unknown>;
+    options?: Record<string, unknown>;
+    sqOptions?: SubQueryOptions;
+}
+interface RootDataQueryMeta {
+    target: 'data';
+    name: string;
+    op: RootDataOperation;
+    id?: string;
+    filter?: unknown;
+    data?: unknown;
+    args?: Record<string, unknown>;
+    options?: Record<string, unknown>;
+}
+type RootQueryMeta = RootModelQueryMeta | RootDataQueryMeta;
+interface SubQueryMeta {
+    model: string;
+    op: 'list' | 'read';
+    id?: string;
+    filter?: unknown;
+    args?: Record<string, unknown>;
+    options?: Record<string, unknown>;
+    sqOptions?: SubQueryOptions;
+}
+interface ModelPromiseMeta {
+    __op: string;
+    __query: RootModelQueryMeta;
+    __requestConfig?: AxiosRequestConfig;
+    __service?: ModelService<Document>;
+}
+interface LazyRequest<T> extends Promise<T> {
+    exec(): Promise<T>;
+}
+type DataResponse<T> = Response<T, T>;
+type ArrayDataResponse<T> = Response<T[], T[]>;
+type ListDataResponse<T> = ArrayDataResponse<T> & {
+    totalCount: number;
+};
+interface DataPromiseMeta {
+    __op: string;
+    __query: RootDataQueryMeta;
+    __requestConfig?: AxiosRequestConfig;
+    __service?: DataService<unknown>;
+}
+declare const wrapLazyPromise: <T, M = undefined>(promiseFn: () => Promise<T>, meta?: M) => M & LazyRequest<T>;
+type ResponseCallback = (res: unknown) => void;
+interface WrapOptions {
+    queryParams?: Record<string, unknown>;
+    pathParams?: Record<string, string | number>;
+}
+
+interface ResultError {
+    success: boolean;
+    raw: unknown;
+    data: unknown;
+    message: string;
+    status: number;
+    headers: Record<string, unknown>;
+}
+declare class Service {
+    protected _axios: AxiosInstance;
+    protected _basePath: string;
+    constructor(axios: AxiosInstance, basePath: string);
+    protected handleSuccess(res: AxiosResponse<unknown, unknown>, extra?: {}): Response<unknown>;
+    protected handleError<T extends ResultError>(error: {
+        response?: {
+            status: number;
+            headers: Record<string, unknown>;
+            data: unknown;
+        };
+        request?: unknown;
+        message?: string;
+    }): T;
+    wrapGet<T = unknown>(url: string, defaultAxiosRequestConfig?: AxiosRequestConfig): (options?: WrapOptions, axiosRequestConfig?: AxiosRequestConfig) => Promise<AxiosResponse<T, any, {}>>;
+    wrapPost<T = unknown>(url: string, defaultAxiosRequestConfig?: AxiosRequestConfig): (data?: unknown, options?: WrapOptions, axiosRequestConfig?: AxiosRequestConfig) => Promise<AxiosResponse<T, any, {}>>;
+    wrapPut<T = unknown>(url: string, defaultAxiosRequestConfig?: AxiosRequestConfig): (data?: unknown, options?: WrapOptions, axiosRequestConfig?: AxiosRequestConfig) => Promise<AxiosResponse<T, any, {}>>;
+    wrapPatch<T = unknown>(url: string, defaultAxiosRequestConfig?: AxiosRequestConfig): (data?: unknown, options?: WrapOptions, axiosRequestConfig?: AxiosRequestConfig) => Promise<AxiosResponse<T, any, {}>>;
+    wrapDelete<T = unknown>(url: string, defaultAxiosRequestConfig?: AxiosRequestConfig): (options?: WrapOptions, axiosRequestConfig?: AxiosRequestConfig) => Promise<AxiosResponse<T, any, {}>>;
+    updateHeaders(headers: AxiosRequestConfig['headers'], { ignoreCache }: {
+        ignoreCache?: boolean;
+    }): AxiosHeaders | (Partial<axios.RawAxiosHeaders & {
+        Accept: axios.AxiosHeaderValue;
+        "Content-Length": axios.AxiosHeaderValue;
+        "User-Agent": axios.AxiosHeaderValue;
+        "Content-Encoding": axios.AxiosHeaderValue;
+        Authorization: axios.AxiosHeaderValue;
+        Location: axios.AxiosHeaderValue;
+    } & {
+        'Content-Type': axios.AxiosHeaderValue;
+    }> & Partial<{
+        get: AxiosHeaders;
+        delete: AxiosHeaders;
+        head: AxiosHeaders;
+        options: AxiosHeaders;
+        post: AxiosHeaders;
+        put: AxiosHeaders;
+        patch: AxiosHeaders;
+        purge: AxiosHeaders;
+        link: AxiosHeaders;
+        unlink: AxiosHeaders;
+        query: AxiosHeaders;
+    } & {
+        common: AxiosHeaders;
+    }>);
+}
+declare class ServiceError extends Error {
+    success: boolean;
+    raw: unknown;
+    data: unknown;
+    status: number;
+    headers: Record<string, unknown>;
+    constructor(result: ResultError);
+}
+
+type RequestConfig$1 = AxiosRequestConfig & AdditionalReqConfig;
+interface Props$1 {
+    axios: AxiosInstance;
+    modelName: string;
+    basePath: string;
+    queryPath: string;
+    mutationPath: string;
+    onSuccess: ResponseCallback;
+    onFailure: ResponseCallback;
+    throwOnError: boolean;
+}
+declare class ModelService<T extends Document> extends Service {
+    private _modelName;
+    private _queryPath;
+    private _mutationPath;
+    private _handleCallbacks;
+    private _defaults;
+    constructor({ axios, modelName, basePath, queryPath, mutationPath, onSuccess, onFailure, throwOnError }: Props$1, defaults?: Defaults);
+    list<TData extends Partial<T> = T>(args?: ListArgs, options?: ListOptions, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ListModelResponse<T, TData>>;
+    listAdvanced<TData extends Partial<T> | never = never, TSelect extends Projection = Projection>(filter: FilterQuery<T>, args?: ListAdvancedArgs<TSelect>, options?: ListAdvancedOptions, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ListModelResponse<T, ResolvedSelectedShape<T, TSelect, TData>>>;
+    read<TData extends Partial<T> = T>(identifier: string, options?: ReadOptions, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ModelResponse<T, TData>>;
+    readAdvanced<TData extends Partial<T> | never = never, TSelect extends Projection = Projection>(identifier: string, args?: ReadAdvancedArgs<TSelect>, options?: ReadAdvancedOptions, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ModelResponse<T, ResolvedSelectedShape<T, TSelect, TData>>>;
+    readAdvancedFilter<TData extends Partial<T> | never = never, TSelect extends Projection = Projection>(filter: FilterQuery<T>, args?: ReadAdvancedArgs<TSelect>, options?: ReadAdvancedOptions, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ModelResponse<T, ResolvedSelectedShape<T, TSelect, TData>>>;
+    new<TData extends Partial<T> = T>(axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ModelResponse<T, TData>>;
+    create<TData extends Partial<T> = T>(data: object, options?: CreateOptions, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ModelResponse<T, TData>>;
+    createAdvanced<TData extends Partial<T> | never = never, TSelect extends Projection = Projection>(data: object, args?: CreateAdvancedArgs<TSelect>, options?: CreateAdvancedOptions, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ModelResponse<T, ResolvedSelectedShape<T, TSelect, TData>>>;
+    update<TData extends Partial<T> = T>(identifier: string, data: object, options?: UpdateOptions, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ModelResponse<T, TData>>;
+    updateAdvanced<TData extends Partial<T> | never = never, TSelect extends Projection = Projection>(identifier: string, data: object, args?: UpdateAdvancedArgs<TSelect>, options?: UpdateAdvancedOptions, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ModelResponse<T, ResolvedSelectedShape<T, TSelect, TData>>>;
+    upsert<TData extends Partial<T> = T>(data: object, options?: UpsertOptions, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ModelResponse<T, TData>>;
+    upsertAdvanced<TData extends Partial<T> | never = never, TSelect extends Projection = Projection>(data: object, args?: UpsertAdvancedArgs<TSelect>, options?: UpsertAdvancedOptions, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<ModelResponse<T, ResolvedSelectedShape<T, TSelect, TData>>>;
+    delete(identifier: string, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<Response<string, string>>;
+    distinct(field: string, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<Response<string[], string[]>>;
+    distinctAdvanced(field: string, conditions: FilterQuery<T>, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<Response<string[], string[]>>;
+    count(axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<Response<number, number>>;
+    countAdvanced(filter: FilterQuery<T>, args?: {
+        access?: string;
+    }, axiosRequestConfig?: RequestConfig$1): ModelPromiseMeta & Promise<Response<number, number>>;
+    id(id: string): {
+        subs: <S = T>(field: keyof T) => {
+            list: (axiosRequestConfig?: RequestConfig$1) => ModelPromiseMeta & Promise<ListModelResponse<S>>;
+            listAdvanced: <TData extends Partial<S> | never = never, TSelect extends readonly string[] = readonly string[]>(filter?: FilterQuery<S>, args?: {
+                select?: TSelect;
+            }, axiosRequestConfig?: RequestConfig$1) => ModelPromiseMeta & Promise<ListModelResponse<S, ResolvedSelectedShape<S, TSelect, TData>>>;
+            read: (subId: string, axiosRequestConfig?: RequestConfig$1) => ModelPromiseMeta & Promise<ModelResponse<S>>;
+            readAdvanced: <TData extends Partial<S> | never = never, TSelect_1 extends readonly string[] = readonly string[]>(subId: string, args?: {
+                select?: TSelect_1;
+                populate?: unknown;
+            }, axiosRequestConfig?: RequestConfig$1) => ModelPromiseMeta & Promise<ModelResponse<S, ResolvedSelectedShape<S, TSelect_1, TData>>>;
+            update: (subId: string, data: object, axiosRequestConfig?: RequestConfig$1) => ModelPromiseMeta & Promise<ModelResponse<S>>;
+            bulkUpdate: (data: object[], _options?: object, axiosRequestConfig?: RequestConfig$1) => ModelPromiseMeta & Promise<ListModelResponse<S>>;
+            create: (data: object, axiosRequestConfig?: RequestConfig$1) => ModelPromiseMeta & Promise<ModelResponse<S>>;
+            delete: (subId: string, axiosRequestConfig?: RequestConfig$1) => ModelPromiseMeta & Promise<Response<string, string>>;
+        };
+        fetch: (args?: ReadAdvancedArgs, options?: ReadAdvancedOptions, axiosRequestConfig?: RequestConfig$1) => ModelPromiseMeta & Promise<ModelResponse<T, Partial<T>>>;
+    };
+    private processListResult;
+}
+
+type RequestConfig = AxiosRequestConfig & AdditionalReqConfig;
+interface Props {
+    axios: AxiosInstance;
+    dataName: string;
+    basePath: string;
+    queryPath: string;
+    onSuccess: ResponseCallback;
+    onFailure: ResponseCallback;
+    throwOnError: boolean;
+}
+declare class DataService<T> extends Service {
+    private _dataName;
+    private _queryPath;
+    private _handleCallbacks;
+    private _defaults;
+    constructor({ axios, dataName, basePath, queryPath, onSuccess, onFailure, throwOnError }: Props, defaults?: DataDefaults);
+    list<TData extends Partial<T> = T>(args?: DataListArgs, options?: DataListOptions, axiosRequestConfig?: RequestConfig): DataPromiseMeta & Promise<ListDataResponse<TData>>;
+    listAdvanced<TData extends Partial<T> | never = never, TSelect extends Projection = Projection>(filter: FilterQuery<T>, args?: DataListAdvancedArgs<TSelect>, options?: DataListAdvancedOptions, axiosRequestConfig?: RequestConfig): DataPromiseMeta & Promise<ListDataResponse<ResolvedSelectedShape<T, TSelect, TData>>>;
+    read<TData extends Partial<T> = T>(identifier: string, options?: DataReadOptions, axiosRequestConfig?: RequestConfig): DataPromiseMeta & Promise<DataResponse<TData>>;
+    readAdvanced<TData extends Partial<T> | never = never, TSelect extends Projection = Projection>(identifier: string, args?: DataReadAdvancedArgs<TSelect>, options?: DataReadAdvancedOptions, axiosRequestConfig?: RequestConfig): DataPromiseMeta & Promise<DataResponse<ResolvedSelectedShape<T, TSelect, TData>>>;
+    readAdvancedFilter<TData extends Partial<T> | never = never, TSelect extends Projection = Projection>(filter: FilterQuery<T>, args?: DataReadAdvancedArgs<TSelect>, options?: DataReadAdvancedOptions, axiosRequestConfig?: RequestConfig): DataPromiseMeta & Promise<DataResponse<ResolvedSelectedShape<T, TSelect, TData>>>;
+    private processListResult;
+}
+
+interface AdapterOptions {
+    rootRouterPath?: string;
+    onSuccess?: ResponseCallback;
+    onFailure?: ResponseCallback;
+    throwOnError?: boolean;
+    cacheTTL?: number;
+}
+interface ModelServiceOptions {
+    modelName: string;
+    basePath: string;
+    queryPath?: string;
+    mutationPath?: string;
+    onSuccess?: ResponseCallback;
+    onFailure?: ResponseCallback;
+    throwOnError?: boolean;
+}
+interface DataServiceOptions {
+    dataName: string;
+    basePath: string;
+    queryPath?: string;
+    onSuccess?: ResponseCallback;
+    onFailure?: ResponseCallback;
+    throwOnError?: boolean;
+}
+declare function createAdapter(axiosConfig?: AxiosRequestConfig, adapterOptions?: AdapterOptions): Readonly<{
+    axios: axios.AxiosInstance;
+    createModelService: <T>({ modelName, basePath, queryPath, mutationPath, onSuccess, onFailure, throwOnError, }: ModelServiceOptions, defaults?: Defaults) => ModelService<T>;
+    createDataService: <T>({ dataName, basePath, queryPath, onSuccess, onFailure, throwOnError }: DataServiceOptions, defaults?: DataDefaults) => DataService<T>;
+    wrapGet: <T = unknown>(url: string, defaultAxiosRequestConfig?: AxiosRequestConfig) => (options?: WrapOptions, axiosRequestConfig?: AxiosRequestConfig) => Promise<axios.AxiosResponse<T, any, {}>>;
+    wrapPost: <T = unknown>(url: string, defaultAxiosRequestConfig?: AxiosRequestConfig) => (data?: unknown, options?: WrapOptions, axiosRequestConfig?: AxiosRequestConfig) => Promise<axios.AxiosResponse<T, any, {}>>;
+    wrapPut: <T = unknown>(url: string, defaultAxiosRequestConfig?: AxiosRequestConfig) => (data?: unknown, options?: WrapOptions, axiosRequestConfig?: AxiosRequestConfig) => Promise<axios.AxiosResponse<T, any, {}>>;
+    wrapPatch: <T = unknown>(url: string, defaultAxiosRequestConfig?: AxiosRequestConfig) => (data?: unknown, options?: WrapOptions, axiosRequestConfig?: AxiosRequestConfig) => Promise<axios.AxiosResponse<T, any, {}>>;
+    wrapDelete: <T = unknown>(url: string, defaultAxiosRequestConfig?: AxiosRequestConfig) => (options?: WrapOptions, axiosRequestConfig?: AxiosRequestConfig) => Promise<axios.AxiosResponse<T, any, {}>>;
+    group: <T extends ((ModelPromiseMeta | DataPromiseMeta) & LazyRequest<unknown>)[]>(...proms: T) => Promise<{ [K in keyof T]: T[K] extends Promise<infer U> ? U : never; }>;
+}>;
+
+declare function replaceItemById<T extends {
+    _id: string;
+}>(items: T[], newItem: T, options?: {
+    merge: boolean;
+}): T[];
+declare function removeItemById<T extends {
+    _id: string;
+}>(items: T[], newItem: T): T[];
+
+declare const _default: {
+    createAdapter: typeof createAdapter;
+};
+
+export { type ArrayDataResponse, type ArrayModelResponse, type DataPromiseMeta, type DataResponse, DataService, type Document, type FilterQuery, type Include, type KeyValueProjection, type LazyRequest, type ListDataResponse, type ListModelResponse, Model, type ModelPromiseMeta, type ModelResponse, ModelService, type Populate, type PopulateAccess, type Projection, type ResolvedSelectedShape, type Response, type ResponseCallback, type ResultError, type RootDataQueryMeta, type RootModelQueryMeta, type RootQueryMeta, type SelectedKeys, type SelectedShape, Service, ServiceError, type Sort, type SortOrder, type SubQueryMeta, type Task, type WrapOptions, createAdapter, _default as default, removeItemById, replaceItemById, wrapLazyPromise };