proto.io 0.0.227 → 0.0.229

package/dist/internals/index-OwgXw07h.d.mts

@@ -0,0 +1,2107 @@
+import * as _o2ter_utils_js from '@o2ter/utils-js';
+import { BinaryData, asyncStream, Awaitable } from '@o2ter/utils-js';
+import jwt, { SignOptions, VerifyOptions } from 'jsonwebtoken';
+import { Request, CookieOptions } from '@o2ter/server-js';
+import Decimal$1, { Decimal } from 'decimal.js';
+import _$1 from 'lodash';
+import { Readable } from 'node:stream';
+import * as socket_io_client from 'socket.io-client';
+import { Socket } from 'socket.io-client';
+
+type _Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+type _Lower = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type _Upper = Uppercase<_Lower>;
+type _Alphabet = _Lower | _Upper;
+type _String<T extends string, C extends string | number> = T extends `${infer H}${C}` ? H extends '' | _String<H, C> ? T : never : never;
+type Digits<T extends string> = T extends `${number}` ? T : never;
+type FieldName<T extends string> = string extends T ? string : T extends `${'_' | _Alphabet}${'' | _String<infer _U, '_' | '-' | _Alphabet | _Digit>}` ? T : never;
+type PathArrayGetter<T extends string> = T extends `[${Digits<infer _T>}]` ? T : T extends `[${Digits<infer L>}]${infer R}` ? `[${L}]${PathArrayGetter<R>}` : never;
+type PathComponent<T extends string> = T extends Digits<T> | FieldName<T> ? T : T extends `${Digits<infer L> | FieldName<infer L>}[${infer _R}` ? `${L}${PathArrayGetter<`[${_R}`>}` : never;
+type PathComponents<T extends string> = T extends PathComponent<T> ? T : T extends `${PathComponent<infer L>}.${infer R}` ? `${L}.${PathComponents<R>}` : never;
+type PathName<T extends string> = string extends T ? string : T extends '$' | PathComponent<T> ? T : T extends `${infer L}.${infer R}` ? `${PathComponent<L>}.${PathComponents<R>}` : never;
+type IncludePath<T extends string> = T extends '*' | FieldName<T> ? T : T extends `${infer L}.${infer R}` ? `${FieldName<L>}.${IncludePath<R>}` : never;
+type IncludePaths<T extends _$1.RecursiveArray<string>> = T extends [] ? [] : T extends [infer H extends string, ...infer R extends _$1.RecursiveArray<string>] ? H extends undefined ? IncludePaths<R> : [IncludePath<H>, ...IncludePaths<R>] : T;
+type PathNameMap<T extends object> = Exact<T, {
+    [K in keyof T as K extends string ? PathName<K> : never]: T[K];
+}>;
+
+declare class TUser extends TObject {
+    constructor(attributes?: Record<string, TValue> | ((self: TObject) => Record<string, TValue>));
+}
+
+/**
+ * Class representing a Role.
+ * @extends TObject
+ */
+declare class TRole extends TObject {
+    constructor(attributes?: Record<string, TValue> | ((self: TObject) => Record<string, TValue>));
+    /**
+     * Get the name of the role.
+     * @return {string | undefined} The name of the role.
+     */
+    get name(): string | undefined;
+    /**
+     * Get the users associated with the role.
+     * @return {TUser[]} The users associated with the role.
+     */
+    get users(): TUser[];
+    /**
+     * Set the users associated with the role.
+     * @param {TUser[]} value - The users to associate with the role.
+     */
+    set users(value: TUser[]);
+    /**
+     * Get the roles associated with the role.
+     * @return {TRole[]} The roles associated with the role.
+     */
+    get roles(): TRole[];
+    /**
+     * Set the roles associated with the role.
+     * @param {TRole[]} value - The roles to associate with the role.
+     */
+    set roles(value: TRole[]);
+}
+
+/**
+ * Represents a stream of data that can be read.
+ * It can be either a ReadableStream or a Readable.
+ */
+type FileStream = ReadableStream | Readable;
+/**
+ * Represents the data of a file.
+ * It can be a string, Blob, BinaryData, FileStream, or an object containing a base64 string.
+ */
+type FileData = string | Blob | BinaryData | FileStream | {
+    base64: string;
+};
+
+/**
+ * Interface representing a file.
+ */
+interface TFile {
+    /**
+     * URL of the file.
+     */
+    url: string | undefined;
+    /**
+     * Retrieves the file data.
+     * @param options - Optional extra options.
+     * @returns A FileStream containing the file data.
+     */
+    fileData(options?: ExtraOptions<boolean>): FileStream;
+    /**
+     * Saves the file.
+     * @param options - Optional extra options including cascadeSave and uploadToken.
+     * @returns A promise that resolves to the current instance.
+     */
+    save(options?: ExtraOptions<boolean> & {
+        cascadeSave?: boolean;
+        uploadToken?: string;
+    }): PromiseLike<this>;
+}
+/**
+ * Class representing a file.
+ */
+declare class TFile extends TObject {
+    constructor(attributes?: Record<string, TValue> | ((self: TObject) => Record<string, TValue>));
+    /**
+     * Gets the filename of the file.
+     * @returns The filename.
+     */
+    get filename(): string | undefined;
+    /**
+     * Gets the size of the file.
+     * @returns The size of the file.
+     */
+    get size(): number | undefined;
+    /**
+     * Gets the type of the file.
+     * @returns The type of the file.
+     */
+    get type(): string | undefined;
+    /**
+     * Gets the token of the file.
+     * @returns The token of the file.
+     */
+    get token(): string | undefined;
+}
+
+/**
+ * Class representing a Job.
+ * @extends TObject
+ */
+declare class TJob extends TObject {
+    constructor(attributes?: Record<string, TValue> | ((self: TObject) => Record<string, TValue>));
+    /**
+     * Get the name of the job.
+     * @return {string} The name of the job.
+     */
+    get name(): string;
+    /**
+     * Get the data of the job.
+     * @return {TValue | undefined} The data of the job.
+     */
+    get data(): TValue | undefined;
+    /**
+     * Get the user associated with the job.
+     * @return {TUser | undefined} The user associated with the job.
+     */
+    get user(): TUser | undefined;
+    /**
+     * Get the error of the job.
+     * @return {TValue | undefined} The error of the job.
+     */
+    get error(): TValue | undefined;
+    /**
+     * Get the start time of the job.
+     * @return {Date | undefined} The start time of the job.
+     */
+    get startedAt(): Date | undefined;
+    /**
+     * Get the completion time of the job.
+     * @return {Date | undefined} The completion time of the job.
+     */
+    get completedAt(): Date | undefined;
+}
+
+declare class TSession extends TObject {
+    constructor(attributes?: Record<string, TValue> | ((self: TObject) => Record<string, TValue>));
+    /**
+     * Get the session ID.
+     * @return {string} The session ID.
+     */
+    get sessionId(): string;
+    /**
+     * Get the user associated with the session.
+     * @return {TObject | undefined} The user associated with the session.
+     */
+    get user(): TObject | undefined;
+    get loginedAt(): Date | undefined;
+}
+
+declare const TObjectTypes: {
+    User: typeof TUser;
+    Role: typeof TRole;
+    File: typeof TFile;
+    _Job: typeof TJob;
+    _Session: typeof TSession;
+};
+type _TObjectType<K> = K extends keyof typeof TObjectTypes ? InstanceType<(typeof TObjectTypes)[K]> : TObject;
+type PickBy<T, C> = {
+    [P in keyof T as T[P] extends C ? P : never]: T[P];
+};
+type PropertyDescriptor<T> = {
+    enumerable?: boolean;
+    get: () => T;
+    set?: (value: T) => void;
+};
+type ReadOnlyProperty<T> = Pick<PropertyDescriptor<T>, 'get'>;
+type ReadWriteProperty<T> = Required<Pick<PropertyDescriptor<T>, 'get' | 'set'>>;
+type PropertyMapToMethods<T> = PickBy<T, Function> & {
+    [P in keyof PickBy<T, ReadWriteProperty<any>>]: T[P] extends PropertyDescriptor<infer V> ? V : never;
+} & {
+    readonly [P in keyof PickBy<T, ReadOnlyProperty<any>>]: T[P] extends PropertyDescriptor<infer V> ? V : never;
+};
+type Property<T> = T extends Function ? T | PropertyDescriptor<T> : PropertyDescriptor<T>;
+type PropertyMap<T, O, A> = {
+    [K in keyof T]: T[K] extends Property<any> ? T[K] : never;
+} & ThisType<O & PropertyMapToMethods<T> & PropertyMapToMethods<A>>;
+type TExtensions<E> = {
+    [K in keyof E]: PropertyMap<E[K], _TObjectType<K>, '*' extends keyof E ? Omit<E['*'], keyof E[K]> : {}>;
+};
+type _TMethods<K, E> = K extends keyof E ? '*' extends keyof E ? PropertyMapToMethods<Omit<E['*'], keyof E[K]> & E[K]> : PropertyMapToMethods<E[K]> : {};
+type IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
+type TMethods<K, E> = IfAny<E, {}, _TMethods<K, E>>;
+type TObjectType<K, E> = _TObjectType<K> & TMethods<K, E>;
+declare const TUpdateOpKeys: readonly ["$set", "$inc", "$dec", "$mul", "$div", "$max", "$min", "$addToSet", "$push", "$removeAll", "$popFirst", "$popLast"];
+type TUpdateOp = ExactOneProp<Record<(typeof TUpdateOpKeys)[number], TValueWithUndefined>>;
+
+declare const TComparisonKeys: readonly ["$eq", "$gt", "$gte", "$lt", "$lte", "$ne"];
+declare const TValueListKeys: readonly ["$in", "$nin"];
+declare const TValueSetKeys: readonly ["$subset", "$superset", "$intersect"];
+declare const TConditionalKeys: readonly ["$and", "$nor", "$or"];
+
+declare const TZeroParamExprKeys: readonly ["$now", "$rand"];
+declare const TUnaryExprKeys: readonly ["$abs", "$neg", "$sqrt", "$cbrt", "$ceil", "$floor", "$round", "$exp", "$ln", "$log2", "$log10", "$sin", "$cos", "$tan", "$asin", "$acos", "$atan", "$asinh", "$acosh", "$atanh", "$sinh", "$cosh", "$tanh", "$degrees", "$radians", "$sign", "$size", "$lower", "$upper"];
+declare const TBinaryExprKeys: readonly ["$divide", "$subtract", "$log", "$pow", "$atan2", "$trim", "$ltrim", "$rtrim", "$first", "$last", "$ldrop", "$rdrop"];
+declare const TTernaryExprKeys: readonly ["$lpad", "$rpad"];
+declare const TListExprKeys: readonly ["$add", "$multiply", "$ifNull", "$concat"];
+declare const TDistanceExprKeys: readonly ["$distance", "$innerProduct", "$negInnerProduct", "$cosineDistance", "$rectilinearDistance"];
+type TBooleanExpression = {
+    $not?: TBooleanExpression;
+} & {
+    [x in (typeof TComparisonKeys)[number]]?: [TExpression, TExpression];
+} & {
+    [x in (typeof TConditionalKeys)[number]]?: TBooleanExpression[];
+};
+type TDistanceExpression = {
+    [x in (typeof TDistanceExprKeys)[number]]?: [
+        TExpression[] | {
+            $key: string;
+        } | {
+            $value: number[];
+        },
+        TExpression[] | {
+            $key: string;
+        } | {
+            $value: number[];
+        }
+    ];
+};
+type TExpression = {
+    $array?: TExpression[];
+    $key?: string;
+    $value?: TValue;
+} & {
+    $cond?: {
+        branch: _.Many<{
+            case: TExpression;
+            then: TExpression;
+        }[]>;
+        default: TExpression;
+    };
+} & {
+    [x in (typeof TZeroParamExprKeys)[number]]?: true | {};
+} & {
+    [x in (typeof TUnaryExprKeys)[number]]?: TExpression;
+} & {
+    [x in (typeof TBinaryExprKeys)[number]]?: [TExpression, TExpression];
+} & {
+    [x in (typeof TTernaryExprKeys)[number]]?: [TExpression, TExpression, TExpression];
+} & {
+    [x in (typeof TListExprKeys)[number]]?: TExpression[];
+} & TBooleanExpression & TDistanceExpression;
+
+type TThisQuerySelector = {
+    $?: TFieldQuerySelector;
+};
+type TFieldQuerySelector = {
+    $not?: TFieldQuerySelector;
+    $starts?: string;
+    $ends?: string;
+    $pattern?: RegExp | string;
+    $size?: number;
+    $empty?: boolean;
+    $every?: TQuerySelector | TThisQuerySelector;
+    $some?: TQuerySelector | TThisQuerySelector;
+} & {
+    [x in (typeof TComparisonKeys)[number]]?: TValue;
+} & {
+    [x in (typeof TValueListKeys)[number]]?: TValue[];
+} & {
+    [x in (typeof TValueSetKeys)[number]]?: TValue[];
+};
+type TCoditionalQuerySelector = {
+    [x in (typeof TConditionalKeys)[number]]?: TQuerySelector[];
+};
+type TQuerySelector = (TCoditionalQuerySelector & {
+    $expr?: TBooleanExpression;
+}) | {
+    [x: string]: TFieldQuerySelector;
+};
+
+declare const TUnaryAccumulatorKeys: readonly ["$max", "$min", "$most", "$sum", "$avg", "$stdDevPop", "$stdDevSamp", "$varPop", "$varSamp"];
+declare const TZeroParamAccumulatorKeys: readonly ["$count"];
+type TQueryAccumulator = {
+    $percentile?: {
+        input: TExpression;
+        p: number;
+        mode?: 'discrete' | 'continuous';
+    };
+    $group?: {
+        key: TExpression;
+        value: Omit<TQueryAccumulator, '$group'>;
+    };
+} & {
+    [x in (typeof TZeroParamAccumulatorKeys)[number]]?: true | {};
+} & {
+    [x in (typeof TUnaryAccumulatorKeys)[number]]?: TExpression;
+};
+type TAccumulatorResult<A extends TQueryAccumulator> = A extends {
+    $group: any;
+} ? {
+    key: any;
+    value: any;
+}[] : A extends {
+    $count: any;
+} ? number : any;
+
+/**
+ * Options for a query filter.
+ */
+interface TQueryFilterBaseOptions {
+    /**
+     * The filter(s) to apply to the query.
+     */
+    filter?: TQuerySelector | TQuerySelector[];
+}
+/**
+ * Sort option for a query.
+ */
+type TSortOption = {
+    /**
+     * The expression to sort by.
+     */
+    expr: TExpression;
+    /**
+     * The order of sorting, 1 for ascending and -1 for descending.
+     */
+    order: 1 | -1;
+};
+/**
+ * Base options for a query.
+ */
+interface TQueryBaseOptions extends TQueryFilterBaseOptions {
+    /**
+     * The sorting options for the query.
+     */
+    sort?: Record<string, 1 | -1> | TSortOption[];
+    /**
+     * The number of results to skip.
+     */
+    skip?: number;
+    /**
+     * The limit on the number of results.
+     */
+    limit?: number;
+    /**
+     * Nested query options for matching specific fields.
+     */
+    matches?: Record<string, TQueryBaseOptions>;
+    /**
+     * Groups the query results by the specified key and applies the provided accumulators.
+     */
+    groupMatches?: Record<string, Record<string, TQueryAccumulator>>;
+}
+/**
+ * Base class for query filters.
+ */
+declare class TQueryFilterBase {
+    /**
+     * Applies a filter to the query.
+     * @param filter - The filter to apply.
+     * @returns The current instance for chaining.
+     */
+    filter(filter: TQuerySelector): this;
+    /**
+     * Applies an equality filter to the query.
+     * @param key - The key to filter.
+     * @param value - The value to filter.
+     * @returns The current instance for chaining.
+     */
+    equalTo<T extends string>(key: PathName<T>, value: TValueWithUndefined): this;
+    /**
+     * Applies a not equal filter to the query.
+     * @param key - The key to filter.
+     * @param value - The value to filter.
+     * @returns The current instance for chaining.
+     */
+    notEqualTo<T extends string>(key: PathName<T>, value: TValueWithUndefined): this;
+    /**
+     * Applies a less than filter to the query.
+     * @param key - The key to filter.
+     * @param value - The value to filter.
+     * @returns The current instance for chaining.
+     */
+    lessThan<T extends string>(key: PathName<T>, value: TValueWithUndefined): this;
+    /**
+     * Applies a greater than filter to the query.
+     * @param key - The key to filter.
+     * @param value - The value to filter.
+     * @returns The current instance for chaining.
+     */
+    greaterThan<T extends string>(key: PathName<T>, value: TValueWithUndefined): this;
+    /**
+     * Applies a less than or equal to filter to the query.
+     * @param key - The key to filter.
+     * @param value - The value to filter.
+     * @returns The current instance for chaining.
+     */
+    lessThanOrEqualTo<T extends string>(key: PathName<T>, value: TValueWithUndefined): this;
+    /**
+     * Applies a greater than or equal to filter to the query.
+     * @param key - The key to filter.
+     * @param value - The value to filter.
+     * @returns The current instance for chaining.
+     */
+    greaterThanOrEqualTo<T extends string>(key: PathName<T>, value: TValueWithUndefined): this;
+    /**
+     * Applies a pattern filter to the query.
+     * @param key - The key to filter.
+     * @param value - The pattern to filter.
+     * @returns The current instance for chaining.
+     */
+    pattern<T extends string>(key: PathName<T>, value: RegExp | string): this;
+    /**
+     * Applies a starts with filter to the query.
+     * @param key - The key to filter.
+     * @param value - The value to filter.
+     * @returns The current instance for chaining.
+     */
+    startsWith<T extends string>(key: PathName<T>, value: string): this;
+    /**
+     * Applies an ends with filter to the query.
+     * @param key - The key to filter.
+     * @param value - The value to filter.
+     * @returns The current instance for chaining.
+     */
+    endsWith<T extends string>(key: PathName<T>, value: string): this;
+    /**
+     * Applies a size filter to the query.
+     * @param key - The key to filter.
+     * @param value - The value to filter.
+     * @returns The current instance for chaining.
+     */
+    size<T extends string>(key: PathName<T>, value: number): this;
+    /**
+     * Applies an empty filter to the query.
+     * @param key - The key to filter.
+     * @returns The current instance for chaining.
+     */
+    empty<T extends string>(key: PathName<T>): this;
+    /**
+     * Applies a not empty filter to the query.
+     * @param key - The key to filter.
+     * @returns The current instance for chaining.
+     */
+    notEmpty<T extends string>(key: PathName<T>): this;
+    /**
+     * Filters the query to include only documents where the specified key contains any of the specified values.
+     * @param key - The key to check for values.
+     * @param value - The array of values to check for.
+     * @returns The current instance for chaining.
+     */
+    containedIn<T extends string>(key: PathName<T>, value: TValueWithUndefined[]): this;
+    /**
+     * Filters the query to exclude documents where the specified key contains any of the specified values.
+     * @param key - The key to check for values.
+     * @param value - The array of values to exclude.
+     * @returns The current instance for chaining.
+     */
+    notContainedIn<T extends string>(key: PathName<T>, value: TValueWithUndefined[]): this;
+    /**
+     * Filters the query to include only documents where the specified key contains all of the specified values.
+     * @param key - The key to check for containing values.
+     * @param value - The array of values to check against.
+     * @returns The current instance for chaining.
+     */
+    containedBy<T extends string>(key: PathName<T>, value: TValueWithUndefined[]): this;
+    /**
+     * Filters the query to exclude documents where the specified key contains all of the specified values.
+     * @param key - The key to check for superset.
+     * @param value - The array of values to check against.
+     * @returns The current instance for chaining.
+     */
+    notContainedBy<T extends string>(key: PathName<T>, value: TValueWithUndefined[]): this;
+    /**
+     * Filters the query to include only documents where the specified key is a subset of the specified values.
+     * @param key - The key to check for subset.
+     * @param value - The array of values to check against.
+     * @returns The current instance for chaining.
+     */
+    isSubset<T extends string>(key: PathName<T>, value: TValueWithUndefined[]): this;
+    /**
+     * Filters the query to include only documents where the specified key is a superset of the specified values.
+     * @param key - The key to check for superset.
+     * @param value - The array of values to check against.
+     * @returns The current instance for chaining.
+     */
+    isSuperset<T extends string>(key: PathName<T>, value: TValueWithUndefined[]): this;
+    /**
+     * Filters the query to include only documents where the specified key is disjoint from the specified values.
+     * @param key - The key to check for disjoint.
+     * @param value - The array of values to check against.
+     * @returns The current instance for chaining.
+     */
+    isDisjoint<T extends string>(key: PathName<T>, value: TValueWithUndefined[]): this;
+    /**
+     * Filters the query to include only documents where the specified key intersects with the specified values.
+     * @param key - The key to check for intersection.
+     * @param value - The array of values to check against.
+     * @returns The current instance for chaining.
+     */
+    isIntersect<T extends string>(key: PathName<T>, value: TValueWithUndefined[]): this;
+    /**
+     * Filters the query to include only documents where every element of the specified key matches the provided callback query.
+     * @param key - The key to check for every element.
+     * @param callback - The callback query to apply to each element.
+     * @returns The current instance for chaining.
+     */
+    every<T extends string>(key: PathName<T>, callback: (query: TQueryFilterBase) => void): this;
+    /**
+     * Filters the query to include only documents where some elements of the specified key match the provided callback query.
+     * @param key - The key to check for some elements.
+     * @param callback - The callback query to apply to each element.
+     * @returns The current instance for chaining.
+     */
+    some<T extends string>(key: PathName<T>, callback: (query: TQueryFilterBase) => void): this;
+    /**
+     * Filters the query to include only documents that match all of the provided callback queries.
+     * @param callbacks - The callback queries to apply.
+     * @returns The current instance for chaining.
+     */
+    and(...callbacks: _$1.Many<(query: TQueryFilterBase) => void>[]): this;
+    /**
+     * Filters the query to include only documents that match any of the provided callback queries.
+     * @param callbacks - The callback queries to apply.
+     * @returns The current instance for chaining.
+     */
+    or(...callbacks: _$1.Many<(query: TQueryFilterBase) => void>[]): this;
+    /**
+     * Filters the query to include only documents that do not match any of the provided callback queries.
+     * @param callbacks - The callback queries to apply.
+     * @returns The current instance for chaining.
+     */
+    nor(...callbacks: _$1.Many<(query: TQueryFilterBase) => void>[]): this;
+}
+declare class TQueryBase extends TQueryFilterBase {
+    /**
+     * Sorts the query results.
+     * @param sort - The sorting criteria.
+     * @returns The current instance for chaining.
+     */
+    sort<T extends Record<string, 1 | -1>>(sort: PathNameMap<T> | TSortOption[]): this;
+    /**
+     * Skips the specified number of results.
+     * @param skip - The number of results to skip.
+     * @returns The current instance for chaining.
+     */
+    skip(skip: number): this;
+    /**
+     * Limits the number of results.
+     * @param limit - The maximum number of results to return.
+     * @returns The current instance for chaining.
+     */
+    limit(limit: number): this;
+    /**
+     * Performs a nested query on a specific key.
+     * @param key - The key to match.
+     * @param callback - The callback function to execute.
+     * @returns The current instance for chaining.
+     */
+    match<T extends string>(key: PathName<T>, callback: (query: TQueryBase) => void): this;
+    /**
+     * Groups the query results by the specified key and applies the provided accumulators.
+     * @param key - The key to group by.
+     * @param accumulators - The accumulators to apply.
+     * @returns The current instance for chaining.
+     */
+    groupMatches<T extends string>(key: PathName<T>, accumulators: Record<string, TQueryAccumulator>): this;
+}
+
+declare class LiveQuerySubscription<T extends string, E> {
+    private _className;
+    private _proto;
+    private _filter;
+    constructor(className: T, proto: ProtoType<E>, filter: TQuerySelector | TQuerySelector[]);
+    get className(): T;
+    on(event: 'create' | 'update' | 'delete', callback: (object: TObjectType<T, E>) => void): {
+        remove: VoidFunction;
+        socket?: socket_io_client.Socket;
+    };
+}
+
+/**
+ * Options for a query.
+ */
+interface TQueryOptions extends TQueryBaseOptions {
+    /**
+     * Fields to include in the query.
+     */
+    includes?: string[];
+}
+/**
+ * Options for a random query.
+ */
+interface TQueryRandomOptions {
+    /**
+     * Field to use for weighting the random selection.
+     */
+    weight?: TExpression;
+}
+/**
+ * Abstract base class for queries.
+ */
+declare abstract class TQuery<T extends string, Ext, M extends boolean> extends TQueryBase {
+    /**
+     * Clones the query with optional new options.
+     * @param options - The new options for the query.
+     * @returns A new query instance.
+     */
+    abstract clone(options?: TQueryOptions): TQuery<T, Ext, M>;
+    /**
+     * Explains the query execution plan.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the explanation.
+     */
+    abstract explain(options?: ExtraOptions<M>): PromiseLike<any>;
+    /**
+     * Counts the number of results for the query.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the count.
+     */
+    abstract count(options?: ExtraOptions<M>): PromiseLike<number>;
+    /**
+     * Finds the results for the query.
+     * @param options - Extra options for the query.
+     * @returns A stream of the results.
+     */
+    abstract find(options?: ExtraOptions<M>): ReturnType<typeof asyncStream<TObjectType<T, Ext>>>;
+    /**
+     * Selects a random result for the query.
+     * @param opts - Options for the random selection.
+     * @param options - Extra options for the query.
+     * @returns A stream of the random result.
+     */
+    abstract random(opts?: TQueryRandomOptions, options?: ExtraOptions<M>): ReturnType<typeof asyncStream<TObjectType<T, Ext>>>;
+    /**
+     * Finds grouped results for the query.
+     * @param accumulators - The accumulators to use for grouping.
+     * @param options - Extra options for the query.
+     * @returns A stream of the grouped results.
+     */
+    abstract groupFind<T extends Record<string, TQueryAccumulator>>(accumulators: T, options?: ExtraOptions<M>): Promise<{
+        [K in keyof T]: TAccumulatorResult<T[K]>;
+    }>;
+    /**
+     * Finds non-reference results for the query.
+     * @param options - Extra options for the query.
+     * @returns A stream of the non-reference results.
+     */
+    abstract nonrefs(options?: ExtraOptions<M>): ReturnType<typeof asyncStream<TObjectType<T, Ext>>>;
+    /**
+     * Inserts a new record.
+     * @param attrs - The attributes of the new record.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the inserted record.
+     */
+    insert(attrs: Record<string, TValueWithUndefined>, options?: ExtraOptions<M>): Promise<TObjectType<T, Ext>>;
+    /**
+     * Inserts multiple new records.
+     * @param values - The attributes of the new records.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the inserted records.
+     */
+    abstract insertMany(values: Record<string, TValueWithUndefined>[], options?: ExtraOptions<M>): PromiseLike<TObjectType<T, Ext>[]>;
+    /**
+     * Updates a single record.
+     * @param update - The update operations.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the updated record or undefined.
+     */
+    updateOne(update: Record<string, TUpdateOp>, options?: ExtraOptions<M>): Promise<TObjectType<T, Ext> | undefined>;
+    /**
+     * Updates multiple records.
+     * @param update - The update operations.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the updated records.
+     */
+    abstract updateMany(update: Record<string, TUpdateOp>, options?: ExtraOptions<M>): PromiseLike<TObjectType<T, Ext>[]>;
+    /**
+     * Upserts a single record.
+     * @param update - The update operations.
+     * @param setOnInsert - The attributes to set on insert.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the upserted record.
+     */
+    upsertOne(update: Record<string, TUpdateOp>, setOnInsert: Record<string, TValueWithUndefined>, options?: ExtraOptions<M>): Promise<TObjectType<T, Ext>>;
+    /**
+     * Upserts multiple records.
+     * @param update - The update operations.
+     * @param setOnInsert - The attributes to set on insert.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the upserted records.
+     */
+    abstract upsertMany(update: Record<string, TUpdateOp>, setOnInsert: Record<string, TValueWithUndefined>, options?: ExtraOptions<M>): PromiseLike<TObjectType<T, Ext>[]>;
+    /**
+     * Deletes a single record.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the deleted record or undefined.
+     */
+    deleteOne(options?: ExtraOptions<M>): Promise<TObjectType<T, Ext> | undefined>;
+    /**
+     * Deletes multiple records.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the deleted records.
+     */
+    abstract deleteMany(options?: ExtraOptions<M>): PromiseLike<TObjectType<T, Ext>[]>;
+    /**
+     * Subscribes to live query updates.
+     * @returns A live query subscription.
+     */
+    abstract subscribe(): LiveQuerySubscription<T, Ext>;
+    /**
+     * Adds fields to include in the query.
+     * @param includes - The fields to include.
+     * @returns The query instance.
+     */
+    includes<T extends _$1.RecursiveArray<string>>(...includes: IncludePaths<T>): this;
+    /**
+     * Gets a record by its ID.
+     * @param id - The ID of the record.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the record or undefined.
+     */
+    get(id: string, options?: ExtraOptions<M>): Promise<TObjectType<T, Ext> | undefined>;
+    /**
+     * Gets the first record.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the first record or undefined.
+     */
+    first(options?: ExtraOptions<M>): Promise<TObjectType<T, Ext> | undefined>;
+    /**
+     * Gets a random record.
+     * @param opts - Options for the random selection.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to the random record or undefined.
+     */
+    randomOne(opts?: TQueryRandomOptions, options?: ExtraOptions<M>): Promise<TObjectType<T, Ext> | undefined>;
+    /**
+     * Checks if any records exist.
+     * @param options - Extra options for the query.
+     * @returns A promise that resolves to a boolean indicating if any records exist.
+     */
+    exists(options?: ExtraOptions<M>): Promise<boolean>;
+    /**
+     * Iterates over each batch of records.
+     * @param callback - The callback to execute for each batch.
+     * @param options - Extra options for the query.
+     */
+    eachBatch(callback: (batch: TObjectType<T, Ext>[]) => Awaitable<void>, options?: ExtraOptions<M> & {
+        batchSize?: number;
+    }): Promise<void>;
+    /**
+     * Iterates over each record.
+     * @param callback - The callback to execute for each record.
+     * @param options - Extra options for the query.
+     */
+    each(callback: (object: TObjectType<T, Ext>) => Awaitable<void>, options?: ExtraOptions<M> & {
+        batchSize?: number;
+    }): Promise<void>;
+    /**
+     * Finds all records matching the query.
+     * @param options - Extra options for the query.
+     * @returns An iterator for the records.
+     */
+    findAll(options?: ExtraOptions<M> & {
+        batchSize?: number;
+    }): _o2ter_utils_js.AsyncStream<Awaited<TObjectType<T, Ext>>>;
+}
+
+type TNumber = number | Decimal | BigInt;
+type TPrimitive = RegExp | Date | string | TNumber | boolean | null | undefined;
+type TSerializable = _TContainer<TPrimitive | TObject>;
+type SerializeOptions = {
+    space?: string | number;
+    objAttrs?: string[];
+};
+type DeserializeOptions = {
+    objAttrs?: string[];
+};
+declare const serialize: (x: TSerializable, options?: SerializeOptions) => string;
+declare const deserialize: (buffer: string, options?: DeserializeOptions) => TSerializable;
+
+/**
+ * A callback function type.
+ * @param request - The request object.
+ * @returns An awaitable response.
+ */
+type Callback<T, R, E> = (request: ProtoService<E> & T) => Awaitable<R>;
+/**
+ * A callback function type.
+ * @param request - The request object.
+ * @returns An awaitable response.
+ */
+type ProtoFunction<E, P extends TSerializable, R extends TSerializable | void> = Callback<{
+    params: P;
+}, R, E>;
+/**
+ * A trigger callback function type.
+ * @param request - The request object.
+ * @returns An awaitable response.
+ */
+type ProtoTriggerFunction<T, E> = Callback<{
+    object: TObjectType<T, E>;
+}, void, E>;
+/**
+ * A job callback function type.
+ * @param request - The request object.
+ * @returns An awaitable response.
+ */
+type ProtoJobFunction<E, P extends TValueWithoutObject> = Callback<{
+    params: P;
+    user?: TUser;
+    job: TObjectType<'_Job', E>;
+}, void, E>;
+/**
+ * Validator options for proto functions.
+ */
+type Validator = {
+    /**
+     * Indicates if a user is required.
+     */
+    requireUser?: boolean;
+    /**
+     * Indicates if a master user is required.
+     */
+    requireMaster?: boolean;
+    /**
+     * Indicates if any user roles are required.
+     */
+    requireAnyUserRoles?: string[];
+    /**
+     * Indicates if all user roles are required.
+     */
+    requireAllUserRoles?: string[];
+};
+/**
+ * Options for configuring a proto function.
+ */
+type ProtoFunctionOptions<E> = {
+    /**
+     * The callback function for the proto function.
+     */
+    callback: ProtoFunction<E, any, any>;
+    /**
+     * Optional validator for the proto function.
+     */
+    validator?: Validator;
+};
+/**
+ * Options for configuring a proto job function.
+ */
+type ProtoJobFunctionOptions<E> = {
+    /**
+     * The callback function for the proto job function.
+     */
+    callback: ProtoJobFunction<E, any>;
+    /**
+     * Optional scopes for the proto job function.
+     */
+    scopes?: string[];
+    /**
+     * Optional validator for the proto function.
+     */
+    validator?: Validator;
+};
+
+type _Session = Awaited<ReturnType<typeof session>>;
+declare const session: <E>(proto: ProtoService<E>, request: Request) => Promise<{
+    user?: TObject | undefined;
+    _roles?: TRole[] | undefined;
+    sessionId?: string | undefined;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
+    loginedAt?: Date | undefined;
+    cookieOptions?: any;
+}>;
+
+declare const _logLevels: readonly ["error", "warn", "info", "debug", "trace"];
+type _Logger = {
+    [x in typeof _logLevels[number]]: (...args: any[]) => void;
+};
+type Logger = _Logger & {
+    loggerLevel: keyof _Logger | 'all' | 'none';
+};
+/**
+ * The mode of the transaction.
+ */
+type TransactionMode = 'default' | 'committed' | 'repeatable' | 'serializable';
+/**
+ * Options for configuring a transaction.
+ */
+type TransactionOptions = {
+    /**
+     * The mode of the transaction.
+     */
+    mode?: TransactionMode;
+    /**
+     * The number of retries or a boolean indicating whether to retry.
+     */
+    retry?: number | boolean;
+};
+/**
+ * Represents event data with additional metadata.
+ */
+type EventData = Record<string, TValueWithoutObject> & {
+    /**
+     * The unique identifier for the event.
+     */
+    _id: string;
+    /**
+     * The creation date of the event.
+     */
+    _created_at: Date;
+    /**
+     * The read permissions for the event.
+     */
+    _rperm: string[];
+};
+declare abstract class ProtoType<Ext> {
+    isQuery: (x: any) => x is TQuery<any, any, any>;
+    isObject: (x: any) => x is TObject;
+    isUser: (x: any) => x is TUser;
+    isRole: (x: any) => x is TRole;
+    isFile: (x: any) => x is TFile;
+    isJob: (x: any) => x is TJob;
+    /**
+     * Gets the endpoint URL.
+     * @returns The endpoint URL as a string.
+     */
+    get endpoint(): string;
+    /**
+     * Retrieves the configuration.
+     * @param options - Optional settings for retrieving the configuration.
+     * @returns A promise that resolves to the configuration.
+     */
+    abstract config(options?: {
+        master?: boolean;
+    }): Promise<Record<string, TValueWithoutObject>>;
+    /**
+     * Retrieves the ACL of configuration.
+     * @param options - Settings for retrieving the ACL of configuration.
+     * @returns A promise that resolves to the ACL of configuration.
+     */
+    abstract configAcl(options: {
+        master: true;
+    }): PromiseLike<Record<string, string[]>>;
+    /**
+     * Sets the configuration.
+     * @param values - The configuration values to set.
+     * @param options - Settings for setting the configuration.
+     * @returns A promise that resolves when the configuration is set.
+     */
+    abstract setConfig(values: Record<string, TValueWithoutObject>, options: {
+        master: true;
+        acl?: string[];
+    }): Promise<void>;
+    /**
+     * Runs a function.
+     * @param name - The name of the function to run.
+     * @param data - The data to pass to the function.
+     * @param options - Additional options for running the function.
+     * @returns A promise that resolves to the result of the function.
+     */
+    abstract run<R extends TSerializable | void = any>(name: string, data?: TSerializable, options?: ExtraOptions<boolean>): Promise<R>;
+    /**
+     * Schedules a job.
+     * @param name - The name of the job to schedule.
+     * @param params - The parameters to pass to the job.
+     * @param options - Additional options for scheduling the job.
+     * @returns A promise that resolves when the job is scheduled.
+     */
+    abstract scheduleJob(name: string, params?: TValueWithoutObject, options?: ExtraOptions<boolean>): Promise<TJob>;
+    /**
+     * Creates a query.
+     * @param className - The name of the class to query.
+     * @returns A query instance.
+     */
+    abstract Query<T extends string>(className: T): TQuery<T, Ext, boolean>;
+    /**
+     * Creates a relation query.
+     * @param object - The object to create the relation for.
+     * @param key - The key of the relation.
+     * @returns A relation query instance.
+     */
+    abstract Relation<T extends string>(object: TObject, key: PathName<T>): TQuery<string, Ext, boolean>;
+    /**
+     * Get all references to an object.
+     * @param object - The object to get references for.
+     * @param options - Additional options for getting references.
+     * @returns A stream of references.
+     */
+    abstract refs(object: TObject, options?: ExtraOptions<boolean>): ReturnType<typeof asyncStream<TObjectType<string, Ext>>>;
+    /**
+     * Checks if the server is online.
+     * @returns A promise that resolves to a boolean indicating if the server is online.
+     */
+    online(): Promise<boolean>;
+    /**
+     * Rebinds an object to the proto instance.
+     * @param object - The object to rebind.
+     * @returns The rebinded object.
+     */
+    rebind<T extends TSerializable | undefined>(object: T): T;
+    /**
+     * Creates a new object.
+     * @param className - The name of the class to create.
+     * @param id - The ID of the object to create.
+     * @returns The created object.
+     */
+    Object<T extends string>(className: T, id?: string): TObjectType<T, Ext>;
+    /**
+     * Creates a new file object.
+     * @param filename - The name of the file.
+     * @param data - The file data.
+     * @param type - The type of the file.
+     * @returns The created file object.
+     */
+    File(filename: string, data: FileData, type?: string): TObjectType<"File", Ext>;
+    /**
+     * Notifies an event.
+     * @param data - The data to notify.
+     * @param options - Additional options for notifying the event.
+     */
+    abstract notify(data: Record<string, TValueWithoutObject> & {
+        _rperm?: string[];
+    }, options?: ExtraOptions<boolean>): Promise<void>;
+    /**
+     * Listens for events.
+     * @param callback - The callback to call when an event occurs.
+     * @returns An object with a remove function to stop listening.
+     */
+    abstract listen(callback: (data: EventData) => void, selector?: TQuerySelector): {
+        remove: VoidFunction;
+        socket?: Socket;
+    };
+}
+interface ProtoType<Ext> {
+    get logger(): Logger;
+    /**
+     * Connects a request with optional attributes.
+     * @param req - The request to connect.
+     * @param attrs - Optional attributes or a function returning attributes.
+     * @returns The instance with the request and attributes.
+     */
+    connect<R extends Request, T extends object>(req: R, attrs?: T | ((x: this & {
+        req: R;
+    }) => T)): this & {
+        req: R;
+    } & T;
+    /**
+     * Connects using a session token with optional attributes.
+     * @param token - The session token.
+     * @param attrs - Optional attributes or a function returning attributes.
+     * @returns A promise resolving to the instance with the session and attributes.
+     */
+    connectWithSessionToken<T extends object>(token: string, attrs?: T | ((x: this & {
+        session?: _Session;
+    }) => T)): Promise<this & {
+        session?: _Session;
+    } & T>;
+    /**
+     * Refreshes the authentication/session status for the socket connection.
+     *
+     * This method should be called when the session token or authentication state changes,
+     * ensuring that any active socket connections are updated to reflect the new session.
+     * Useful for maintaining real-time features (such as LiveQuery) after login, logout,
+     * or session renewal.
+     */
+    refreshSocketSession(): void;
+    /**
+     * Sets the session token.
+     * @param token - The session token.
+     */
+    setSessionToken(token?: string): void;
+    /**
+     * Retrieves the roles of a user.
+     * @param user - The user whose roles are to be retrieved.
+     * @returns A promise resolving to an array of roles.
+     */
+    userRoles(user: TUser): Promise<TRole[]>;
+    /**
+     * Becomes a specified user.
+     * @param req - The request.
+     * @param user - The user to become.
+     * @param options - Optional cookie and JWT sign options.
+     * @returns A promise resolving to void.
+     */
+    becomeUser(req: Request, user: TUser, options?: {
+        cookieOptions?: CookieOptions | undefined;
+        jwtSignOptions?: SignOptions | undefined;
+    }): Promise<void>;
+    /**
+     * Logs out a user.
+     * @param req - The request.
+     * @param options - Optional cookie and JWT sign options.
+     * @returns A promise resolving to void.
+     */
+    logoutUser(req: Request, options?: {
+        cookieOptions?: CookieOptions | undefined;
+        jwtSignOptions?: SignOptions | undefined;
+    }): Promise<void>;
+    /**
+     * Verifies a user's password.
+     * @param user - The user whose password is to be verified.
+     * @param password - The password to verify.
+     * @param options - Extra options.
+     * @returns A promise resolving to a boolean indicating if the password is correct.
+     */
+    verifyPassword(user: TUser, password: string, options: ExtraOptions<true>): Promise<boolean>;
+    /**
+     * Sets a user's password.
+     * @param user - The user whose password is to be set.
+     * @param password - The new password.
+     * @param options - Extra options.
+     * @returns A promise resolving to void.
+     */
+    setPassword(user: TUser, password: string, options: ExtraOptions<true>): Promise<void>;
+    /**
+     * Unsets a user's password.
+     * @param user - The user whose password is to be unset.
+     * @param options - Extra options.
+     * @returns A promise resolving to void.
+     */
+    unsetPassword(user: TUser, options: ExtraOptions<true>): Promise<void>;
+    /**
+     * Defines a new function.
+     * @param name - The name of the function.
+     * @param callback - The function callback.
+     * @param options - Optional function options excluding the callback.
+     */
+    define<P extends TSerializable = any, R extends TSerializable | void = any>(name: string, callback: ProtoFunction<Ext, P, R>, options?: Omit<ProtoFunctionOptions<Ext>, 'callback'>): void;
+    /**
+     * Registers a callback to be executed after an object is created.
+     * @param className - The name of the class.
+     * @param callback - The callback function.
+     */
+    afterCreate<T extends string>(className: string, callback: ProtoTriggerFunction<T, Ext>): void;
+    /**
+     * Registers a callback to be executed after an object is updated.
+     * @param className - The name of the class.
+     * @param callback - The callback function.
+     */
+    afterUpdate<T extends string>(className: string, callback: ProtoTriggerFunction<T, Ext>): void;
+    /**
+     * Registers a callback to be executed after an object is deleted.
+     * @param className - The name of the class.
+     * @param callback - The callback function.
+     */
+    afterDelete<T extends string>(className: string, callback: ProtoTriggerFunction<T, Ext>): void;
+    /**
+     * Defines a new job function.
+     * @param name - The name of the job function.
+     * @param callback - The job function callback.
+     * @param options - Optional job function options excluding the callback.
+     */
+    defineJob<P extends TValueWithoutObject = any>(name: string, callback: ProtoJobFunction<Ext, P>, options?: Omit<ProtoJobFunctionOptions<Ext>, 'callback'>): void;
+    /**
+     * Locks a table for updates.
+     * @param className - The name of the class or an array of class names.
+     * @param update - Whether to lock for update.
+     */
+    lockTable(className: string | string[], update: boolean): void;
+    /**
+     * Executes a callback within a transaction.
+     * @param callback - The callback to execute.
+     * @param options - Optional transaction options.
+     */
+    withTransaction<T>(callback: (connection: ProtoType<Ext>) => PromiseLike<T>, options?: TransactionOptions): void;
+    /**
+     * Generates an upload token.
+     * @param options - Optional settings for the upload token.
+     * @returns The generated upload token.
+     */
+    generateUploadToken(options?: {
+        maxUploadSize?: number;
+    }): string;
+    /**
+     * Signs a JWT.
+     * @param payload - The payload to sign.
+     * @param options - Options for signing the JWT.
+     * @returns The signed JWT.
+     */
+    jwtSign(payload: any, options: jwt.SignOptions): string;
+    /**
+     * Verifies a JWT.
+     * @param token - The token to verify.
+     * @param options - Options for verifying the JWT.
+     * @returns The decoded JWT payload or undefined if verification fails.
+     */
+    jwtVerify(token: string, options?: jwt.VerifyOptions): jwt.JwtPayload | undefined;
+}
+
+/**
+ * Represents additional options that can be passed to certain methods.
+ */
+type ExtraOptions<M extends boolean> = {
+    /**
+     * Indicates whether the master option is enabled.
+     */
+    master?: M;
+    /**
+     * The session associated with the operation.
+     */
+    session?: ProtoType<any>;
+    /**
+     * An AbortSignal object that can be used to abort the operation.
+     */
+    abortSignal?: AbortSignal;
+    /**
+     * Disable the triggers.
+     *
+     * Only effective when `master` is `true`.
+     */
+    silent?: boolean;
+};
+
+/**
+ * Interface representing a object.
+ */
+interface TObject {
+    /**
+     * Clones the object.
+     * @returns A clone of the object.
+     */
+    clone(): this;
+    /**
+     * Gets a relation query for the specified key.
+     * @param key - The key of the relation.
+     * @returns A query object for the relation.
+     */
+    relation<T extends string>(key: PathName<T>): TQuery<string, any, boolean>;
+    /**
+     * Fetches the object with the specified keys included.
+     * @param keys - The keys to include.
+     * @param options - Additional options for the fetch operation.
+     * @returns A promise that resolves to the fetched object.
+     */
+    fetchWithInclude<T extends _$1.RecursiveArray<string>>(keys: IncludePaths<T>, options?: ExtraOptions<boolean>): PromiseLike<this>;
+    /**
+     * Saves the object.
+     * @param options - Additional options for the save operation.
+     * @returns A promise that resolves to the saved object.
+     */
+    save(options?: ExtraOptions<boolean> & {
+        cascadeSave?: boolean;
+    }): PromiseLike<this>;
+    /**
+     * Destroys the object.
+     * @param options - Additional options for the destroy operation.
+     * @returns A promise that resolves to the destroyed object.
+     */
+    destroy(options?: ExtraOptions<boolean>): PromiseLike<this>;
+}
+/**
+ * Class representing a object.
+ */
+declare class TObject {
+    static defaultReadonlyKeys: string[];
+    static defaultKeys: string[];
+    constructor(className: string, attributes?: Record<string, TValue> | ((self: TObject) => Record<string, TValue>));
+    /**
+     * Gets the class name of the object.
+     */
+    get className(): string;
+    /**
+     * Gets the attributes of the object.
+     */
+    get attributes(): Record<string, TValue>;
+    /**
+     * Gets the object ID.
+     */
+    get id(): string | undefined;
+    /**
+     * Gets the creation date of the object.
+     */
+    get createdAt(): Date | undefined;
+    /**
+     * Gets the last updated date of the object.
+     */
+    get updatedAt(): Date | undefined;
+    /**
+     * Gets the version number of the object.
+     */
+    get __v(): number;
+    /**
+     * Gets the sequence number of the object.
+     */
+    get __i(): number;
+    /**
+     * Gets the expiration date of the object.
+     */
+    get expiredAt(): Date | undefined;
+    /**
+     * Sets the expiration date of the object.
+     * @param value - The expiration date.
+     */
+    set expiredAt(value: Date | undefined);
+    /**
+     * Gets the access control list (ACL) of the object.
+     * @returns The ACL of the object.
+     */
+    acl(): TSchema.ACLs;
+    /**
+     * Sets the access control list (ACL) of the object.
+     * @param value - The ACL to set.
+     */
+    setAcl(value: Partial<TSchema.ACLs>): void;
+    /**
+     * Sets the read access control list (ACL) of the object.
+     * @param value - The read ACL to set.
+     */
+    setReadAcl(value: TSchema.ACL): void;
+    /**
+     * Sets the write access control list (ACL) of the object.
+     * @param value - The write ACL to set.
+     */
+    setWriteAcl(value: TSchema.ACL): void;
+    /**
+     * Gets the keys of the object's attributes and mutated attributes.
+     * @returns An array of keys.
+     */
+    keys(): string[];
+    /**
+     * Gets an iterator for the entries of the object's attributes.
+     * @returns An iterator for the entries.
+     */
+    entries(): Generator<[string, any], void, unknown>;
+    /**
+     * Converts the object to a plain object.
+     * @param replacer - An optional function to replace values during the conversion.
+     * @returns The plain object representation of the object.
+     */
+    toObject(replacer?: (value: TObject) => any): any;
+    private _value;
+    /**
+     * Get the value of the attribute.
+     * @param key - The key of the attribute.
+     * @returns The value of the attribute.
+     */
+    get<T extends string>(key: PathName<T>): any;
+    /**
+     * Set the value of the attribute.
+     * @param key - The key of the attribute.
+     * @param value - The value to set.
+     */
+    set<T extends string>(key: PathName<T>, value: TValueWithUndefined): void;
+    /**
+     * Is the object dirty.
+     */
+    get isDirty(): boolean;
+    /**
+     * Increment the value of the attribute.
+     * @param key - The key to increment.
+     * @param value - The value to increment by.
+     */
+    increment<T extends string>(key: PathName<T>, value: number | Decimal): void;
+    /**
+     * Decrement the value of the attribute.
+     * @param key - The key to decrement.
+     * @param value - The value to decrement by.
+     */
+    decrement<T extends string>(key: PathName<T>, value: number | Decimal): void;
+    /**
+     * Multiplies the value of the specified attribute.
+     * @param key - The key of the attribute to multiply.
+     * @param value - The multiplier value.
+     */
+    multiply<T extends string>(key: PathName<T>, value: number | Decimal): void;
+    /**
+     * Divides the value of the specified attribute.
+     * @param key - The key of the attribute to divide.
+     * @param value - The divisor value.
+     */
+    divide<T extends string>(key: PathName<T>, value: number | Decimal): void;
+    /**
+     * Sets the value of the specified attribute to the maximum of the current value and the provided value.
+     * @param key - The key of the attribute to compare.
+     * @param value - The value to compare against.
+     */
+    max<T extends string>(key: PathName<T>, value: TValue): void;
+    /**
+     * Sets the value of the specified attribute to the minimum of the current value and the provided value.
+     * @param key - The key of the attribute to compare.
+     * @param value - The value to compare against.
+     */
+    min<T extends string>(key: PathName<T>, value: TValue): void;
+    /**
+     * Adds the specified values to the set of the specified attribute.
+     * @param key - The key of the attribute.
+     * @param values - The values to add to the set.
+     */
+    addToSet<T extends string>(key: PathName<T>, values: TValue[]): void;
+    /**
+     * Adds the values to the array of the attribute.
+     * @param key - The key of the attribute.
+     * @param values - The values to add.
+     */
+    push<T extends string>(key: PathName<T>, values: TValue[]): void;
+    /**
+     * Removes the values from the array of the attribute.
+     * @param key - The key of the attribute.
+     * @param values - The values to remove.
+     */
+    removeAll<T extends string>(key: PathName<T>, values: TValue[]): void;
+    /**
+     * Removes the first elements from the array of the attribute.
+     * @param key - The key of the attribute.
+     * @param count - The number of elements to remove. Defaults to 1.
+     */
+    popFirst<T extends string>(key: PathName<T>, count?: number): void;
+    /**
+     * Removes the last elements from the array of the attribute.
+     * @param key - The key of the attribute.
+     * @param count - The number of elements to remove. Defaults to 1.
+     */
+    popLast<T extends string>(key: PathName<T>, count?: number): void;
+    /**
+     * Fetches the object data.
+     * @param options - Additional options for the fetch operation.
+     * @returns A promise that resolves to the fetched object.
+     */
+    fetch(options?: ExtraOptions<boolean>): Promise<this>;
+    /**
+     * Fetches the object data if needed.
+     * @param keys - The keys of the attributes to fetch.
+     * @param options - Additional options for the fetch operation.
+     * @returns A promise that resolves to the fetched object.
+     */
+    fetchIfNeeded<T extends _$1.RecursiveArray<string>>(keys: IncludePaths<T>, options?: ExtraOptions<boolean>): Promise<this>;
+}
+
+type _TContainer<Primitive> = {
+    [x: string]: _TContainer<Primitive>;
+} | _TContainer<Primitive>[] | Primitive;
+type TPrimitiveValue = boolean | number | Decimal$1 | string | Date | null;
+type TValueWithUndefined = _TContainer<TPrimitiveValue | TObject | undefined>;
+type TValueWithoutObject = _TContainer<TPrimitiveValue>;
+type TValue = _TContainer<TPrimitiveValue | TObject>;
+type Exact<T, Shape> = T extends Shape ? Exclude<keyof T, keyof Shape> extends never ? T : never : never;
+type ExactOneProp<T> = {
+    [K in keyof T]-?: Pick<T, K> & {
+        [P in Exclude<keyof T, K>]?: never;
+    };
+}[keyof T];
+
+declare namespace TSchema {
+    /**
+     * Access Control List (ACL).
+     *
+     * An array of strings representing users or roles that have access to a resource.
+     */
+    type ACL = string[];
+    /**
+     * Access Control Lists for read and update operations.
+     *
+     * Defines separate ACLs for reading and updating an object.
+     */
+    type ACLs = {
+        /**
+         * ACL for read operation.
+         * Users or roles allowed to read the object.
+         */
+        read: TSchema.ACL;
+        /**
+         * ACL for update operation.
+         * Users or roles allowed to update the object.
+         */
+        update: TSchema.ACL;
+    };
+    /**
+     * Supported primitive data types.
+     */
+    type Primitive = 'boolean' | 'number' | 'decimal' | 'string' | 'string[]' | 'date' | 'object' | 'array';
+    /**
+     * Primitive type with optional default value.
+     *
+     * Can be a string literal (e.g., 'string') or an object specifying the type and a default value.
+     */
+    type PrimitiveType = Primitive | {
+        /**
+         * The primitive type.
+         */
+        type: Primitive;
+        /**
+         * Optional default value for the field.
+         */
+        default?: TValueWithoutObject;
+    };
+    /**
+     * Vector type with a specified dimension and optional default value.
+     *
+     * Used for fields storing fixed-length numeric arrays (vectors).
+     */
+    type VectorType = {
+        /**
+         * The type of the field. Always 'vector'.
+         */
+        type: 'vector';
+        /**
+         * The dimension (length) of the vector.
+         */
+        dimension: number;
+        /**
+         * Optional default value for the vector.
+         */
+        default?: number[];
+    };
+    /**
+     * Shape type for nested objects.
+     *
+     * Allows defining complex, nested object structures with their own field types.
+     */
+    type ShapeType = {
+        /**
+         * The type of the field. Always 'shape'.
+         */
+        type: 'shape';
+        /**
+         * The shape definition, mapping field names to their data types.
+         */
+        shape: Record<string, DataType>;
+    };
+    /**
+     * Pointer type for referencing another class.
+     *
+     * Represents a one-to-one relationship to another object.
+     */
+    type PointerType = {
+        /**
+         * The type of the field. Always 'pointer'.
+         */
+        type: 'pointer';
+        /**
+         * The name of the target class being referenced.
+         */
+        target: string;
+    };
+    /**
+     * Relation type for referencing multiple objects in another class.
+     *
+     * Represents a one-to-many or many-to-many relationship.
+     * - `target`: The related class name.
+     * - `foreignField`: (Optional) The field in the target class that refers back to this class.
+     * - `match`: (Optional) Default match query options (filter, sort, etc.) applied when querying this relation.
+     *   Only used if `foreignField` is set.
+     */
+    type RelationType = {
+        /**
+         * The type of the field. Always 'relation'.
+         */
+        type: 'relation';
+        /**
+         * The name of the target class for this relation.
+         */
+        target: string;
+        /**
+         * (Optional) The field in the target class that refers back to this class.
+         * If provided, the relation is managed via this foreign key.
+         */
+        foreignField?: string;
+        /**
+         * (Optional) Default match query options for this relation.
+         *
+         * These options define default query behaviors—such as filtering, sorting, limiting results, and other query parameters—
+         * that will be automatically applied when querying this relation via the specified `foreignField`.
+         *
+         * Note: `match` is only applicable if `foreignField` is set. If `foreignField` is not provided, `match` will be ignored.
+         */
+        match?: TQueryBaseOptions;
+    };
+    /**
+     * Data type for schema fields.
+     *
+     * Can be a primitive, vector, shape, pointer, or relation type.
+     */
+    type DataType = PrimitiveType | VectorType | ShapeType | PointerType | RelationType;
+    /**
+     * Class Level Permissions (CLPs).
+     *
+     * Defines access control for various operations at the class level.
+     */
+    type CLPs = {
+        /**
+         * ACL for get (read single object) operation.
+         */
+        get?: TSchema.ACL;
+        /**
+         * ACL for find (query multiple objects) operation.
+         */
+        find?: TSchema.ACL;
+        /**
+         * ACL for count operation.
+         */
+        count?: TSchema.ACL;
+        /**
+         * ACL for create operation.
+         */
+        create?: TSchema.ACL;
+        /**
+         * ACL for update operation.
+         */
+        update?: TSchema.ACL;
+        /**
+         * ACL for delete operation.
+         */
+        delete?: TSchema.ACL;
+    };
+    /**
+     * Field Level Permissions (FLPs).
+     *
+     * Defines access control for individual fields.
+     */
+    type FLPs = {
+        /**
+         * ACL for reading the field.
+         */
+        read?: TSchema.ACL;
+        /**
+         * ACL for creating the field.
+         */
+        create?: TSchema.ACL;
+        /**
+         * ACL for updating the field.
+         */
+        update?: TSchema.ACL;
+    };
+    /**
+     * Index definitions for the schema.
+     *
+     * Supports both basic and vector indexes.
+     */
+    type Indexes = {
+        /**
+         * Type of the index. Default is 'basic'.
+         */
+        type?: 'basic';
+        /**
+         * Keys for the index, mapping field names to sort order (1 for ascending, -1 for descending).
+         */
+        keys: Record<string, 1 | -1>;
+        /**
+         * Whether the index is unique.
+         */
+        unique?: boolean;
+    } | {
+        /**
+         * Type of the index. Must be 'vector' for vector indexes.
+         */
+        type: 'vector';
+        /**
+         * Keys for the vector index. Can be a single field or an array of fields.
+         */
+        keys: string | string[];
+        /**
+         * Method for the vector index. Supported: 'hnsw', 'ivfflat'.
+         */
+        method?: 'hnsw' | 'ivfflat';
+    };
+}
+interface TSchema {
+    /**
+     * Fields of the schema, where each field is a data type.
+     */
+    fields: Record<string, TSchema.DataType>;
+    /**
+     * Class level permissions for the schema.
+     */
+    classLevelPermissions?: TSchema.CLPs;
+    /**
+     * Additional object permissions for the schema.
+     */
+    additionalObjectPermissions?: TSchema.ACLs;
+    /**
+     * Field level permissions for the schema, where each field can have its own permissions.
+     */
+    fieldLevelPermissions?: Record<string, TSchema.FLPs>;
+    /**
+     * Secure fields in the schema.
+     */
+    secureFields?: string[];
+    /**
+     * Indexes for the schema.
+     */
+    indexes?: TSchema.Indexes[];
+    /**
+     * Indicates if live query is enabled for the schema.
+     */
+    liveQuery?: boolean;
+}
+
+/**
+ * Represents file information.
+ */
+type TFileInfo = {
+    /**
+     * The MIME type of the file.
+     */
+    mimeType?: string;
+    /**
+     * The filename.
+     */
+    filename?: string;
+};
+/**
+ * Interface for file storage operations.
+ */
+interface TFileStorage {
+    /**
+     * The schema definition for the file storage.
+     */
+    schema: Record<string, TSchema>;
+    /**
+     * Creates a new file in the storage.
+     * @param proto - The ProtoService instance.
+     * @param stream - The binary data stream or async iterable of binary data.
+     * @param info - The file information.
+     * @param maxUploadSize - The maximum upload size.
+     * @returns A promise that resolves to an object containing the file ID and size.
+     */
+    create<E>(proto: ProtoService<E>, stream: BinaryData | AsyncIterable<BinaryData>, info: TFileInfo, maxUploadSize: number): PromiseLike<{
+        _id: string;
+        size: number;
+    }>;
+    /**
+     * Destroys a file in the storage.
+     * @param proto - The ProtoService instance.
+     * @param id - The ID of the file to destroy.
+     * @returns A promise that resolves when the file is destroyed.
+     */
+    destroy<E>(proto: ProtoService<E>, id: string): PromiseLike<void>;
+    /**
+     * Retrieves file data from the storage.
+     * @param proto - The ProtoService instance.
+     * @param id - The ID of the file.
+     * @param start - The optional start byte position.
+     * @param end - The optional end byte position.
+     * @returns An async iterable of binary data.
+     */
+    fileData<E>(proto: ProtoService<E>, id: string, start?: number, end?: number): AsyncIterable<BinaryData>;
+}
+
+declare class QueryExpression {
+    static decode(expr: _$1.Many<TExpression>, dollerSign: boolean): QueryExpression;
+    simplify(): QueryExpression;
+    keyPaths(): string[];
+    mapKey(callback: (key: string) => string): QueryExpression;
+    eval(value: any): any;
+    evalType(schema: Record<string, TSchema>, className: string): TSchema.DataType[];
+}
+
+declare class QuerySelector {
+    static decode(selectors: _$1.Many<TQuerySelector>, dollerSign?: boolean): QuerySelector;
+    simplify(): QuerySelector;
+    keyPaths(): string[];
+    eval(value: any): boolean;
+}
+declare class FieldSelectorExpression {
+    type: keyof TFieldQuerySelector;
+    value: QuerySelector | FieldSelectorExpression | RegExp | TValue;
+    constructor(type: keyof TFieldQuerySelector, value: QuerySelector | FieldSelectorExpression | RegExp | TValue);
+    static decode(selector: TFieldQuerySelector): FieldSelectorExpression;
+    simplify(): FieldSelectorExpression;
+    keyPaths(field?: string): string[];
+    eval(value: any): any;
+}
+
+declare class QueryAccumulator {
+    static decode(query: TQueryAccumulator): QueryAccumulator;
+    simplify(): QueryAccumulator;
+    keyPaths(): string[];
+    mapKey(callback: (key: string) => string): QueryAccumulator;
+    evalType(schema: Record<string, TSchema>, className: string): TSchema.DataType | undefined;
+}
+
+type FindOptions = {
+    className: string;
+} & TQueryOptions;
+type RelationOptions = {
+    relatedBy?: {
+        className: string;
+        id: string;
+        key: string;
+    };
+};
+type Decoded<T, R> = Omit<T, keyof R> & R;
+type DecodedSortOption = {
+    expr: QueryExpression;
+    order: 1 | -1;
+};
+type DecodedBaseQuery = Decoded<TQueryBaseOptions, {
+    filter?: QuerySelector;
+    matches: Record<string, DecodedBaseQuery>;
+    groupMatches?: Record<string, Record<string, QueryAccumulator>>;
+    sort?: Record<string, 1 | -1> | DecodedSortOption[];
+}>;
+type DecodedQuery<T> = Decoded<T, {
+    filter: QuerySelector;
+    matches: Record<string, DecodedBaseQuery>;
+    groupMatches: Record<string, Record<string, QueryAccumulator>>;
+    includes: string[];
+    objectIdSize: number;
+    sort?: Record<string, 1 | -1> | DecodedSortOption[];
+    extraFilter?: (className: string) => QuerySelector;
+}>;
+type InsertOptions = {
+    className: string;
+    includes: string[];
+    matches: Record<string, DecodedBaseQuery>;
+    groupMatches: Record<string, Record<string, QueryAccumulator>>;
+    objectIdSize: number;
+};
+type QueryRandomOptions = {
+    weight?: QueryExpression;
+};
+interface TStorage {
+    selectLock(): boolean;
+    prepare(schema: Record<string, TSchema>): PromiseLike<void>;
+    shutdown(): PromiseLike<void>;
+    classes(): string[];
+    config(acl?: string[]): PromiseLike<Record<string, TValueWithoutObject>>;
+    configAcl(): PromiseLike<Record<string, string[]>>;
+    setConfig(values: Record<string, TValueWithoutObject>, acl?: string[]): PromiseLike<void>;
+    explain(query: DecodedQuery<FindOptions & RelationOptions>): PromiseLike<any>;
+    count(query: DecodedQuery<FindOptions & RelationOptions>): PromiseLike<number>;
+    find(query: DecodedQuery<FindOptions & RelationOptions>): AsyncIterable<TObject>;
+    random(query: DecodedQuery<FindOptions & RelationOptions>, opts?: QueryRandomOptions): AsyncIterable<TObject>;
+    groupFind(query: DecodedQuery<FindOptions & RelationOptions>, accumulators: Record<string, QueryAccumulator>): PromiseLike<Record<string, any>>;
+    refs(object: TObject, classNames: string[], roles?: string[]): AsyncIterable<TObject>;
+    nonrefs(query: DecodedQuery<FindOptions>): AsyncIterable<TObject>;
+    insert(options: InsertOptions, values: Record<string, TValueWithUndefined>[]): PromiseLike<TObject[]>;
+    update(query: DecodedQuery<FindOptions>, update: Record<string, TUpdateOp>): PromiseLike<TObject[]>;
+    upsert(query: DecodedQuery<FindOptions>, update: Record<string, TUpdateOp>, setOnInsert: Record<string, TValueWithUndefined>): PromiseLike<TObject[]>;
+    delete(query: DecodedQuery<FindOptions>): PromiseLike<TObject[]>;
+    lockTable(className: string | string[], update: boolean): Promise<void>;
+    withConnection<T>(callback: (connection: TStorage) => PromiseLike<T>): PromiseLike<T>;
+    isDuplicateIdError(error: any): boolean;
+    atomic<T>(callback: (connection: TStorage) => PromiseLike<T>, options?: {
+        lockTable?: string;
+        retry?: boolean;
+    }): PromiseLike<T>;
+    withTransaction<T>(callback: (connection: TStorage) => PromiseLike<T>, options?: TransactionOptions): PromiseLike<T>;
+}
+
+type _PasswordHashOptions = {
+    'scrypt': {
+        log2n: number;
+        blockSize: number;
+        parallel: number;
+        keySize: number;
+        saltSize: number;
+    };
+};
+type PasswordHashOptions = {
+    [K in keyof _PasswordHashOptions]: {
+        alg: K;
+    } & _PasswordHashOptions[K];
+}[keyof _PasswordHashOptions];
+
+/**
+ * Interface for publish-subscribe operations.
+ */
+interface TPubSub {
+    /**
+     * Subscribes to a channel.
+     * @param channel - The name of the channel to subscribe to.
+     * @param callback - The callback function to handle the event data.
+     * @returns A function to unsubscribe from the channel.
+     */
+    subscribe(channel: string, callback: (payload: TValueWithoutObject) => void): VoidFunction;
+    /**
+     * Publishes an event to a channel.
+     * @param channel - The name of the channel to publish to.
+     * @param payload - The event data to publish.
+     * @returns A promise that resolves when the event is published.
+     */
+    publish(channel: string, payload: TValueWithoutObject): Awaitable<void>;
+}
+
+type ProtoServiceOptions<Ext> = {
+    /**
+     * The endpoint for the service.
+     */
+    endpoint: string;
+    /**
+     * The schema definitions for the service.
+     */
+    schema: Record<string, TSchema>;
+    /**
+     * Role resolver configuration.
+     */
+    roleResolver?: {
+        /**
+         * Keys to inherit roles.
+         */
+        inheritKeys?: string[];
+        /**
+         * Custom resolver function for roles.
+         * @param user The user object.
+         * @param defaultResolver The default resolver function.
+         * @returns A promise that resolves to an array of roles.
+         */
+        resolver?: (user: TUser, defaultResolver: () => Promise<TRole[]>) => Awaitable<TRole[]>;
+    };
+    /**
+     * Logger configuration.
+     */
+    logger?: Partial<Logger>;
+    /**
+     * Storage configuration.
+     */
+    storage: TStorage;
+    /**
+     * File storage configuration.
+     */
+    fileStorage: TFileStorage;
+    /**
+     * Pub/Sub configuration.
+     */
+    pubsub?: TPubSub;
+    /**
+     * Class extensions configuration.
+     */
+    classExtends?: TExtensions<Ext>;
+    /**
+     * Size of the object ID.
+     */
+    objectIdSize?: number;
+    /**
+     * Maximum fetch limit.
+     */
+    maxFetchLimit?: number;
+    /**
+     * Maximum upload size.
+     */
+    maxUploadSize?: number;
+    /**
+     * Cookie options.
+     */
+    cookieOptions?: CookieOptions;
+    /**
+     * JWT sign options.
+     */
+    jwtSignOptions?: SignOptions;
+    /**
+     * JWT verify options.
+     */
+    jwtVerifyOptions?: VerifyOptions;
+    /**
+     * JWT upload sign options.
+     */
+    jwtUploadSignOptions?: SignOptions;
+    /**
+     * JWT upload verify options.
+     */
+    jwtUploadVerifyOptions?: VerifyOptions;
+    /**
+     * Password hash options.
+     */
+    passwordHashOptions?: PasswordHashOptions;
+    /**
+     * Password policy options.
+     */
+    passwordPolicy?: {
+        /**
+         * Do not allow reusing previous passwords.
+         */
+        maxPasswordHistory?: number;
+        /**
+         * Custom validator callback for password strength.
+         * @param password The password to validate.
+         * @param user The user object (optional).
+         * @returns A boolean or a promise that resolves to a boolean indicating whether the password is valid.
+         */
+        validatorCallback?: (password: string, user?: TUser) => Awaitable<boolean>;
+    };
+};
+type ProtoServiceKeyOptions = {
+    /**
+     * JWT token for the service.
+     */
+    jwtToken: string;
+    /**
+     * Master users configuration.
+     */
+    masterUsers?: {
+        /**
+         * Username of the master user.
+         */
+        user: string;
+        /**
+         * Password of the master user.
+         */
+        pass: string;
+    }[];
+};
+
+declare class ProtoService<Ext = any> extends ProtoType<Ext> {
+    private _storage?;
+    private _schedule;
+    req?: Request;
+    session?: _Session;
+    constructor(options: ProtoServiceOptions<Ext> & ProtoServiceKeyOptions);
+    shutdown(): Promise<void>;
+    get logger(): Logger;
+    classes(): string[];
+    Query<T extends string>(className: T): TQuery<T, Ext, boolean>;
+    Relation<T extends string>(object: TObject, key: PathName<T>): TQuery<string, Ext, boolean>;
+    InsecureQuery<T extends string>(className: T): TQuery<T, Ext, true>;
+    sessionInfo(): Promise<{
+        user?: TObject | undefined;
+        _roles?: TRole[] | undefined;
+        sessionId?: string | undefined;
+        createdAt?: Date | undefined;
+        updatedAt?: Date | undefined;
+        loginedAt?: Date | undefined;
+        cookieOptions?: any;
+    } | undefined>;
+    currentUser(): Promise<TUser | undefined>;
+    _currentRoles(): Promise<TRole[]>;
+    currentRoles(): Promise<string[]>;
+    get isMaster(): boolean;
+    get isInvalidMasterToken(): boolean;
+    connect<R extends Request, T extends object>(req: R, attrs?: T | ((x: this & {
+        req: R;
+    }) => T)): this & {
+        req: R;
+    } & T;
+    connectWithSessionToken<T extends object>(token: string, attrs?: T | ((x: this & {
+        session?: _Session;
+    }) => T)): Promise<this & {
+        session?: _Session;
+    } & T>;
+    userRoles(user: TUser): Promise<TRole[]>;
+    becomeUser(req: Request, user: TUser, options?: {
+        cookieOptions?: CookieOptions | undefined;
+        jwtSignOptions?: jwt.SignOptions | undefined;
+    }): Promise<void>;
+    logoutUser(req: Request, options?: {
+        cookieOptions?: CookieOptions | undefined;
+        jwtSignOptions?: jwt.SignOptions | undefined;
+    }): Promise<void>;
+    verifyPassword(user: TUser, password: string, options: ExtraOptions<true>): Promise<boolean>;
+    setPassword(user: TUser, password: string, options: ExtraOptions<true>): Promise<void>;
+    unsetPassword(user: TUser, options: ExtraOptions<true>): Promise<void>;
+    get schema(): ProtoServiceOptions<Ext>['schema'];
+    get storage(): ProtoServiceOptions<Ext>['storage'];
+    get fileStorage(): ProtoServiceOptions<Ext>['fileStorage'];
+    config(options?: {
+        master?: boolean;
+    }): Promise<Record<string, TValueWithoutObject>>;
+    configAcl(options: {
+        master: true;
+    }): PromiseLike<Record<string, string[]>>;
+    setConfig(values: Record<string, TValueWithoutObject>, options: {
+        master: true;
+        acl?: string[];
+    }): Promise<void>;
+    run<R extends TSerializable | void = any>(name: string, params?: TSerializable, options?: ExtraOptions<boolean>): Promise<R>;
+    define<P extends TSerializable = any, R extends TSerializable | void = any>(name: string, callback: ProtoFunction<Ext, P, R>, options?: Omit<ProtoFunctionOptions<Ext>, 'callback'>): void;
+    afterCreate<T extends string>(className: string, callback: ProtoTriggerFunction<T, Ext>): void;
+    afterUpdate<T extends string>(className: string, callback: ProtoTriggerFunction<T, Ext>): void;
+    afterDelete<T extends string>(className: string, callback: ProtoTriggerFunction<T, Ext>): void;
+    scheduleJob(name: string, params?: TValueWithoutObject, options?: ExtraOptions<boolean>): Promise<TObjectType<"_Job", Ext>>;
+    defineJob<P extends TValueWithoutObject = any>(name: string, callback: ProtoJobFunction<Ext, P>, options?: Omit<ProtoJobFunctionOptions<Ext>, 'callback'>): void;
+    lockTable(className: string | string[], update: boolean): Promise<void>;
+    withTransaction<T>(callback: (connection: ProtoService<Ext>) => PromiseLike<T>, options?: TransactionOptions): Promise<T>;
+    generateUploadToken(options?: {
+        maxUploadSize?: number;
+        attributes?: Record<string, TValue>;
+        jwtSignOptions?: jwt.SignOptions;
+    }): string;
+    jwtSign(payload: any, options: jwt.SignOptions): string;
+    jwtVerify(token: string, options?: jwt.VerifyOptions): jwt.JwtPayload | undefined;
+    notify(data: Record<string, TValueWithoutObject> & {
+        _rperm?: string[];
+    }): Promise<void>;
+    listen(callback: (data: EventData) => void, selector?: TQuerySelector): {
+        remove: VoidFunction;
+    };
+    refs(object: TObject, options?: ExtraOptions<boolean>): _o2ter_utils_js.AsyncStream<TObjectType<string, Ext>>;
+    gc(classNames?: string | string[]): Promise<void>;
+}
+
+export { FieldSelectorExpression as F, ProtoService as P, QueryExpression as Q, TSchema as T, deserialize as g, ProtoType as i, TQuery as j, TObject as k, TUser as n, serialize as s, QueryAccumulator as u, QuerySelector as v };
+export type { TransactionOptions as A, QueryRandomOptions as B, TPubSub as C, DeserializeOptions as D, ExtraOptions as E, TFileInfo as G, InsertOptions as I, RelationOptions as R, SerializeOptions as S, ProtoServiceOptions as a, ProtoServiceKeyOptions as b, TValueWithoutObject as c, TFileStorage as d, TNumber as e, TSerializable as f, TExtensions as h, PathName as l, TObjectType as m, EventData as o, TQuerySelector as p, TValueWithUndefined as q, TValue as r, TUpdateOp as t, DecodedQuery as w, FindOptions as x, DecodedSortOption as y, TStorage as z };
+//# sourceMappingURL=index-OwgXw07h.d.mts.map