@feathersjs/feathers 5.0.0-pre.6 → 5.0.0

package/lib/declarations.d.ts

@@ -1,59 +1,127 @@
 /// <reference types="node" />
-import { EventEmitter, NextFunction, HookContext as BaseHookContext } from './dependencies';
-declare type SelfOrArray<S> = S | S[];
-declare type OptionalPick<T, K extends PropertyKey> = Pick<T, Extract<keyof T, K>>;
+import { EventEmitter } from 'events';
+import { NextFunction, HookContext as BaseHookContext } from '@feathersjs/hooks';
+type SelfOrArray<S> = S | S[];
+type OptionalPick<T, K extends PropertyKey> = Pick<T, Extract<keyof T, K>>;
 export type { NextFunction };
+/**
+ * The object returned from `.find` call by standard database adapters
+ */
 export interface Paginated<T> {
     total: number;
     limit: number;
     skip: number;
     data: T[];
 }
-export interface ServiceOptions {
-    events?: string[];
-    methods?: string[];
-    serviceEvents?: string[];
+/**
+ * Options that can be passed when registering a service via `app.use(name, service, options)`
+ */
+export interface ServiceOptions<MethodTypes = string> {
+    /**
+     * A list of custom events that this service emits to clients
+     */
+    events?: string[] | readonly string[];
+    /**
+     * A list of service methods that should be available __externally__ to clients
+     */
+    methods?: MethodTypes[] | readonly MethodTypes[];
+    /**
+     * Provide a full list of events that this service should emit to clients.
+     * Unlike the `events` option, this will not be merged with the default events.
+     */
+    serviceEvents?: string[] | readonly string[];
+    /**
+     * Initial data to always add as route params to this service.
+     */
+    routeParams?: {
+        [key: string]: any;
+    };
+}
+export interface ClientService<Result = any, Data = Partial<Result>, PatchData = Data, FindResult = Paginated<Result>, P = Params> {
+    find(params?: P): Promise<FindResult>;
+    get(id: Id, params?: P): Promise<Result>;
+    create(data: Data[], params?: P): Promise<Result[]>;
+    create(data: Data, params?: P): Promise<Result>;
+    update(id: Id, data: Data, params?: P): Promise<Result>;
+    update(id: NullableId, data: Data, params?: P): Promise<Result | Result[]>;
+    update(id: null, data: Data, params?: P): Promise<Result[]>;
+    patch(id: NullableId, data: PatchData, params?: P): Promise<Result | Result[]>;
+    patch(id: Id, data: PatchData, params?: P): Promise<Result>;
+    patch(id: null, data: PatchData, params?: P): Promise<Result[]>;
+    remove(id: NullableId, params?: P): Promise<Result | Result[]>;
+    remove(id: Id, params?: P): Promise<Result>;
+    remove(id: null, params?: P): Promise<Result[]>;
 }
-export interface ServiceMethods<T, D = Partial<T>> {
-    find(params?: Params): Promise<T | T[]>;
-    get(id: Id, params?: Params): Promise<T>;
-    create(data: D, params?: Params): Promise<T>;
-    update(id: NullableId, data: D, params?: Params): Promise<T | T[]>;
-    patch(id: NullableId, data: D, params?: Params): Promise<T | T[]>;
-    remove(id: NullableId, params?: Params): Promise<T | T[]>;
-    setup(app: Application, path: string): Promise<void>;
+export interface ServiceMethods<Result = any, Data = Partial<Result>, ServiceParams = Params, PatchData = Partial<Data>> {
+    find(params?: ServiceParams): Promise<Result | Result[]>;
+    get(id: Id, params?: ServiceParams): Promise<Result>;
+    create(data: Data, params?: ServiceParams): Promise<Result>;
+    update(id: NullableId, data: Data, params?: ServiceParams): Promise<Result | Result[]>;
+    patch(id: NullableId, data: PatchData, params?: ServiceParams): Promise<Result | Result[]>;
+    remove(id: NullableId, params?: ServiceParams): Promise<Result | Result[]>;
+    setup?(app: Application, path: string): Promise<void>;
+    teardown?(app: Application, path: string): Promise<void>;
 }
-export interface ServiceOverloads<T, D> {
-    create?(data: D[], params?: Params): Promise<T[]>;
-    update?(id: Id, data: D, params?: Params): Promise<T>;
-    update?(id: null, data: D, params?: Params): Promise<T[]>;
-    patch?(id: Id, data: D, params?: Params): Promise<T>;
-    patch?(id: null, data: D, params?: Params): Promise<T[]>;
-    remove?(id: Id, params?: Params): Promise<T>;
-    remove?(id: null, params?: Params): Promise<T[]>;
+export interface ServiceOverloads<Result = any, Data = Partial<Result>, ServiceParams = Params, PatchData = Partial<Data>> {
+    create?(data: Data[], params?: ServiceParams): Promise<Result[]>;
+    update?(id: Id, data: Data, params?: ServiceParams): Promise<Result>;
+    update?(id: null, data: Data, params?: ServiceParams): Promise<Result[]>;
+    patch?(id: Id, data: PatchData, params?: ServiceParams): Promise<Result>;
+    patch?(id: null, data: PatchData, params?: ServiceParams): Promise<Result[]>;
+    remove?(id: Id, params?: ServiceParams): Promise<Result>;
+    remove?(id: null, params?: ServiceParams): Promise<Result[]>;
 }
-export declare type Service<T, D = Partial<T>> = ServiceMethods<T, D> & ServiceOverloads<T, D>;
-export declare type ServiceInterface<T, D = Partial<T>> = Partial<ServiceMethods<T, D>>;
-export interface ServiceAddons<A = Application, S = Service<any, any>> extends EventEmitter {
+/**
+ * A complete service interface. The `ServiceInterface` type should be preferred for customs service
+ * implementations
+ */
+export type Service<Result = any, Data = Partial<Result>, ServiceParams = Params, PatchData = Partial<Data>> = ServiceMethods<Result, Data, ServiceParams> & ServiceOverloads<Result, Data, ServiceParams, PatchData>;
+/**
+ * The `Service` service interface but with none of the methods required.
+ */
+export type ServiceInterface<Result = any, Data = Partial<Result>, ServiceParams = Params, PatchData = Partial<Data>> = Partial<ServiceMethods<Result, Data, ServiceParams, PatchData>>;
+export interface ServiceAddons<A = Application, S = Service> extends EventEmitter {
     id?: string;
     hooks(options: HookOptions<A, S>): this;
 }
-export interface ServiceHookOverloads<S> {
-    find(params: Params, context: HookContext): Promise<HookContext>;
-    get(id: Id, params: Params, context: HookContext): Promise<HookContext>;
-    create(data: ServiceGenericData<S> | ServiceGenericData<S>[], params: Params, context: HookContext): Promise<HookContext>;
-    update(id: NullableId, data: ServiceGenericData<S>, params: Params, context: HookContext): Promise<HookContext>;
-    patch(id: NullableId, data: ServiceGenericData<S>, params: Params, context: HookContext): Promise<HookContext>;
-    remove(id: NullableId, params: Params, context: HookContext): Promise<HookContext>;
+export interface ServiceHookOverloads<S, P = Params> {
+    find(params: P, context: HookContext): Promise<HookContext>;
+    get(id: Id, params: P, context: HookContext): Promise<HookContext>;
+    create(data: ServiceGenericData<S> | ServiceGenericData<S>[], params: P, context: HookContext): Promise<HookContext>;
+    update(id: NullableId, data: ServiceGenericData<S>, params: P, context: HookContext): Promise<HookContext>;
+    patch(id: NullableId, data: ServiceGenericData<S>, params: P, context: HookContext): Promise<HookContext>;
+    remove(id: NullableId, params: P, context: HookContext): Promise<HookContext>;
 }
-export declare type FeathersService<A = FeathersApplication, S = Service<any>> = S & ServiceAddons<A, S> & OptionalPick<ServiceHookOverloads<S>, keyof S>;
-export declare type CustomMethod<Methods extends string> = {
-    [k in Methods]: <X = any>(data: any, params?: Params) => Promise<X>;
+export type FeathersService<A = FeathersApplication, S = Service> = S & ServiceAddons<A, S> & OptionalPick<ServiceHookOverloads<S>, keyof S>;
+export type CustomMethods<T extends {
+    [key: string]: [any, any];
+}> = {
+    [K in keyof T]: (data: T[K][0], params?: Params) => Promise<T[K][1]>;
 };
-export declare type ServiceMixin<A> = (service: FeathersService<A>, path: string, options?: ServiceOptions) => void;
-export declare type ServiceGenericType<S> = S extends ServiceInterface<infer T> ? T : any;
-export declare type ServiceGenericData<S> = S extends ServiceInterface<infer _T, infer D> ? D : any;
-export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
+/**
+ * An interface usually use by transport clients that represents a e.g. HTTP or websocket
+ * connection that can be configured on the application.
+ */
+export type TransportConnection<Services = any> = {
+    (app: Application<Services>): void;
+    Service: any;
+    service: <L extends keyof Services & string>(name: L) => keyof any extends keyof Services ? ServiceInterface : Services[L];
+};
+/**
+ * A real-time connection object
+ */
+export interface RealTimeConnection {
+    [key: string]: any;
+}
+/**
+ * The interface for a custom service method. Can e.g. be used to type client side services.
+ */
+export type CustomMethod<T = any, R = T, P extends Params = Params> = (data: T, params?: P) => Promise<R>;
+export type ServiceMixin<A> = (service: FeathersService<A>, path: string, options: ServiceOptions) => void;
+export type ServiceGenericType<S> = S extends ServiceInterface<infer T> ? T : any;
+export type ServiceGenericData<S> = S extends ServiceInterface<infer _T, infer D> ? D : any;
+export type ServiceGenericParams<S> = S extends ServiceInterface<infer _T, infer _D, infer P> ? P : any;
+export interface FeathersApplication<Services = any, Settings = any> {
     /**
      * The Feathers application version
      */
@@ -61,40 +129,36 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
     /**
      * A list of callbacks that run when a new service is registered
      */
-    mixins: ServiceMixin<Application<ServiceTypes, AppSettings>>[];
+    mixins: ServiceMixin<Application<Services, Settings>>[];
     /**
      * The index of all services keyed by their path.
      *
      * __Important:__ Services should always be retrieved via `app.service('name')`
      * not via `app.services`.
      */
-    services: ServiceTypes;
+    services: Services;
     /**
      * The application settings that can be used via
      * `app.get` and `app.set`
      */
-    settings: AppSettings;
+    settings: Settings;
     /**
      * A private-ish indicator if `app.setup()` has been called already
      */
     _isSetup: boolean;
-    /**
-     * Contains all registered application level hooks.
-     */
-    appHooks: HookMap<Application<ServiceTypes, AppSettings>, any>;
     /**
      * Retrieve an application setting by name
      *
      * @param name The setting name
      */
-    get<L extends keyof AppSettings & string>(name: L): AppSettings[L];
+    get<L extends keyof Settings & string>(name: L): Settings[L];
     /**
      * Set an application setting
      *
      * @param name The setting name
      * @param value The setting value
      */
-    set<L extends keyof AppSettings & string>(name: L, value: AppSettings[L]): this;
+    set<L extends keyof Settings & string>(name: L, value: Settings[L]): this;
     /**
      * Runs a callback configure function with the current application instance.
      *
@@ -108,7 +172,7 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
      *
      * @param location The path of the service
      */
-    defaultService(location: string): ServiceInterface<any>;
+    defaultService(location: string): ServiceInterface;
     /**
      * Register a new service or a sub-app. When passed another
      * Feathers application, all its services will be re-registered
@@ -119,7 +183,13 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
      * Feathers application to use a sub-app under the `path` prefix.
      * @param options The options for this service
      */
-    use<L extends keyof ServiceTypes & string>(path: L, service: keyof any extends keyof ServiceTypes ? ServiceInterface<any> | Application : ServiceTypes[L], options?: ServiceOptions): this;
+    use<L extends keyof Services & string>(path: L, service: keyof any extends keyof Services ? ServiceInterface | Application : Services[L], options?: ServiceOptions<keyof any extends keyof Services ? string : keyof Services[L]>): this;
+    /**
+     * Unregister an existing service.
+     *
+     * @param path The name of the service to unregister
+     */
+    unuse<L extends keyof Services & string>(path: L): Promise<FeathersService<this, keyof any extends keyof Services ? Service : Services[L]>>;
     /**
      * Get the Feathers service instance for a path. This will
      * be the service originally registered with Feathers functionality
@@ -127,33 +197,60 @@ export interface FeathersApplication<ServiceTypes = any, AppSettings = any> {
      *
      * @param path The name of the service.
      */
-    service<L extends keyof ServiceTypes & string>(path: L): FeathersService<this, keyof any extends keyof ServiceTypes ? Service<any> : ServiceTypes[L]>;
+    service<L extends keyof Services & string>(path: L): FeathersService<this, keyof any extends keyof Services ? Service : Services[L]>;
+    /**
+     * Set up the application and call all services `.setup` method if available.
+     *
+     * @param server A server instance (optional)
+     */
     setup(server?: any): Promise<this>;
+    /**
+     * Tear down the application and call all services `.teardown` method if available.
+     *
+     * @param server A server instance (optional)
+     */
+    teardown(server?: any): Promise<this>;
     /**
      * Register application level hooks.
      *
      * @param map The application hook settings.
      */
-    hooks(map: HookOptions<this, any>): this;
+    hooks(map: ApplicationHookOptions<this>): this;
 }
-export interface Application<ServiceTypes = any, AppSettings = any> extends FeathersApplication<ServiceTypes, AppSettings>, EventEmitter {
+export interface Application<Services = any, Settings = any> extends FeathersApplication<Services, Settings>, EventEmitter {
 }
-export declare type Id = number | string;
-export declare type NullableId = Id | null;
+export type Id = number | string;
+export type NullableId = Id | null;
 export interface Query {
     [key: string]: any;
 }
-export interface Params {
-    query?: Query;
+export interface Params<Q = Query> {
+    query?: Q;
     provider?: string;
     route?: {
-        [key: string]: string;
+        [key: string]: any;
     };
     headers?: {
         [key: string]: any;
     };
-    [key: string]: any;
 }
+export interface Http {
+    /**
+     * A writeable, optional property with status code override.
+     */
+    status?: number;
+    /**
+     * A writeable, optional property with headers.
+     */
+    headers?: {
+        [key: string]: string | string[];
+    };
+    /**
+     * A writeable, optional property with `Location` header's value.
+     */
+    location?: string;
+}
+export type HookType = 'before' | 'after' | 'error' | 'around';
 export interface HookContext<A = Application, S = any> extends BaseHookContext<ServiceGenericType<S>> {
     /**
      * A read only property that contains the Feathers application object. This can be used to
@@ -175,10 +272,9 @@ export interface HookContext<A = Application, S = any> extends BaseHookContext<S
      */
     readonly service: S;
     /**
-     * A read only property with the hook type (one of before, after or error).
-     * Will be `null` for asynchronous hooks.
+     * A read only property with the hook type (one of 'around', 'before', 'after' or 'error').
      */
-    readonly type: null | 'before' | 'after' | 'error';
+    readonly type: HookType;
     /**
      * The list of method arguments. Should not be modified, modify the
      * `params`, `data` and `id` properties instead.
@@ -204,7 +300,7 @@ export interface HookContext<A = Application, S = any> extends BaseHookContext<S
      * A writeable property that contains the service method parameters (including
      * params.query).
      */
-    params: Params;
+    params: ServiceGenericParams<S>;
     /**
      * A writeable property containing the result of the successful service method call.
      * It is only available in after hooks.
@@ -224,28 +320,47 @@ export interface HookContext<A = Application, S = any> extends BaseHookContext<S
     /**
      * A writeable, optional property that allows to override the standard HTTP status
      * code that should be returned.
+     *
+     * @deprecated Use `http.status` instead.
      */
     statusCode?: number;
+    /**
+     * A writeable, optional property with options specific to HTTP transports.
+     */
+    http?: Http;
     /**
      * The event emitted by this method. Can be set to `null` to skip event emitting.
      */
     event: string | null;
 }
-export declare type LegacyHookFunction<A = Application, S = Service<any, any>> = (this: S, context: HookContext<A, S>) => (Promise<HookContext<Application, S> | void> | HookContext<Application, S> | void);
-export declare type Hook<A = Application, S = Service<any, any>> = LegacyHookFunction<A, S>;
-declare type LegacyHookMethodMap<A, S> = {
-    [L in keyof S]?: SelfOrArray<LegacyHookFunction<A, S>>;
+export type HookFunction<A = Application, S = Service> = (this: S, context: HookContext<A, S>) => Promise<HookContext<Application, S> | void> | HookContext<Application, S> | void;
+export type Hook<A = Application, S = Service> = HookFunction<A, S>;
+type HookMethodMap<A, S> = {
+    [L in keyof S]?: SelfOrArray<HookFunction<A, S>>;
 } & {
-    all?: SelfOrArray<LegacyHookFunction<A, S>>;
+    all?: SelfOrArray<HookFunction<A, S>>;
 };
-declare type LegacyHookTypeMap<A, S> = SelfOrArray<LegacyHookFunction<A, S>> | LegacyHookMethodMap<A, S>;
-export declare type LegacyHookMap<A, S> = {
-    before?: LegacyHookTypeMap<A, S>;
-    after?: LegacyHookTypeMap<A, S>;
-    error?: LegacyHookTypeMap<A, S>;
+type HookTypeMap<A, S> = SelfOrArray<HookFunction<A, S>> | HookMethodMap<A, S>;
+export type AroundHookFunction<A = Application, S = Service> = (context: HookContext<A, S>, next: NextFunction) => Promise<void>;
+export type AroundHookMap<A, S> = {
+    [L in keyof S]?: AroundHookFunction<A, S>[];
+} & {
+    all?: AroundHookFunction<A, S>[];
 };
-export declare type HookFunction<A = Application, S = Service<any, any>> = (context: HookContext<A, S>, next: NextFunction) => Promise<void>;
-export declare type HookMap<A, S> = {
-    [L in keyof S]?: HookFunction<A, S>[];
+export type HookMap<A, S> = {
+    around?: AroundHookMap<A, S>;
+    before?: HookTypeMap<A, S>;
+    after?: HookTypeMap<A, S>;
+    error?: HookTypeMap<A, S>;
+};
+export type HookOptions<A, S> = AroundHookMap<A, S> | AroundHookFunction<A, S>[] | HookMap<A, S>;
+export interface ApplicationHookContext<A = Application> extends BaseHookContext {
+    app: A;
+    server: any;
+}
+export type ApplicationHookFunction<A> = (context: ApplicationHookContext<A>, next: NextFunction) => Promise<void>;
+export type ApplicationHookMap<A> = {
+    setup?: ApplicationHookFunction<A>[];
+    teardown?: ApplicationHookFunction<A>[];
 };
-export declare type HookOptions<A, S> = HookMap<A, S> | HookFunction<A, S>[] | LegacyHookMap<A, S>;
+export type ApplicationHookOptions<A> = HookOptions<A, any> | ApplicationHookMap<A>;

package/lib/events.d.ts

@@ -1,4 +1,4 @@
-import { NextFunction } from './dependencies';
+import { NextFunction } from '@feathersjs/hooks';
 import { HookContext, FeathersService } from './declarations';
 export declare function eventHook(context: HookContext, next: NextFunction): Promise<void>;
-export declare function eventMixin<A>(service: FeathersService<A>): FeathersService<A, import("./declarations").Service<any, Partial<any>>>;
+export declare function eventMixin<A>(service: FeathersService<A>): FeathersService<A, import("./declarations").Service<any, Partial<any>, import("./declarations").Params<import("./declarations").Query>, Partial<Partial<any>>>>;

package/lib/events.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.eventMixin = exports.eventHook = void 0;
-const dependencies_1 = require("./dependencies");
+const events_1 = require("events");
 const service_1 = require("./service");
 function eventHook(context, next) {
-    const { events } = service_1.getServiceOptions(context.self);
+    const { events } = (0, service_1.getServiceOptions)(context.self);
     const defaultEvent = service_1.defaultEventMap[context.method] || null;
     context.event = defaultEvent;
     return next().then(() => {
@@ -12,16 +12,15 @@ function eventHook(context, next) {
         // This is used for custom events and for client services receiving event from the server
         if (typeof context.event === 'string' && !events.includes(context.event)) {
             const results = Array.isArray(context.result) ? context.result : [context.result];
-            results.forEach(element => context.self.emit(context.event, element, context));
+            results.forEach((element) => context.self.emit(context.event, element, context));
         }
     });
 }
 exports.eventHook = eventHook;
 function eventMixin(service) {
-    const isEmitter = typeof service.on === 'function' &&
-        typeof service.emit === 'function';
+    const isEmitter = typeof service.on === 'function' && typeof service.emit === 'function';
     if (!isEmitter) {
-        Object.assign(service, dependencies_1.EventEmitter.prototype);
+        Object.assign(service, events_1.EventEmitter.prototype);
     }
     return service;
 }

package/lib/events.js.map

@@ -1 +1 @@
-{"version":3,"file":"events.js","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":";;;AAAA,iDAA4D;AAE5D,uCAA+D;AAE/D,SAAgB,SAAS,CAAE,OAAoB,EAAE,IAAkB;IACjE,MAAM,EAAE,MAAM,EAAE,GAAG,2BAAiB,CAAE,OAAe,CAAC,IAAI,CAAC,CAAC;IAC5D,MAAM,YAAY,GAAI,yBAAuB,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC;IAEtE,OAAO,CAAC,KAAK,GAAG,YAAY,CAAC;IAE7B,OAAO,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;QACtB,+FAA+F;QAC/F,yFAAyF;QACzF,IAAI,OAAO,OAAO,CAAC,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACxE,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,OAAO,CAAC,MAAM,CAAE,CAAC;YAEpF,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAE,OAAe,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;SACzF;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAfD,8BAeC;AAED,SAAgB,UAAU,CAAK,OAA2B;IACxD,MAAM,SAAS,GAAG,OAAO,OAAO,CAAC,EAAE,KAAK,UAAU;QAChD,OAAO,OAAO,CAAC,IAAI,KAAK,UAAU,CAAC;IAErC,IAAI,CAAC,SAAS,EAAE;QACd,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,2BAAY,CAAC,SAAS,CAAC,CAAC;KAChD;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AATD,gCASC"}
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":";;;AAAA,mCAAqC;AAGrC,uCAA8D;AAE9D,SAAgB,SAAS,CAAC,OAAoB,EAAE,IAAkB;IAChE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAA,2BAAiB,EAAE,OAAe,CAAC,IAAI,CAAC,CAAA;IAC3D,MAAM,YAAY,GAAI,yBAAuB,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,IAAI,CAAA;IAErE,OAAO,CAAC,KAAK,GAAG,YAAY,CAAA;IAE5B,OAAO,IAAI,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;QACtB,+FAA+F;QAC/F,yFAAyF;QACzF,IAAI,OAAO,OAAO,CAAC,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACxE,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;YAEjF,OAAO,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAE,OAAe,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAA;SAC1F;IACH,CAAC,CAAC,CAAA;AACJ,CAAC;AAfD,8BAeC;AAED,SAAgB,UAAU,CAAI,OAA2B;IACvD,MAAM,SAAS,GAAG,OAAO,OAAO,CAAC,EAAE,KAAK,UAAU,IAAI,OAAO,OAAO,CAAC,IAAI,KAAK,UAAU,CAAA;IAExF,IAAI,CAAC,SAAS,EAAE;QACd,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,qBAAY,CAAC,SAAS,CAAC,CAAA;KAC/C;IAED,OAAO,OAAO,CAAA;AAChB,CAAC;AARD,gCAQC"}

package/lib/hooks.d.ts

@@ -0,0 +1,42 @@
+import { HookContextData, HookManager, Middleware } from '@feathersjs/hooks';
+import { Service, ServiceOptions, HookContext, FeathersService, HookMap, AroundHookFunction, HookFunction } from './declarations';
+type HookStore = {
+    around: {
+        [method: string]: AroundHookFunction[];
+    };
+    before: {
+        [method: string]: HookFunction[];
+    };
+    after: {
+        [method: string]: HookFunction[];
+    };
+    error: {
+        [method: string]: HookFunction[];
+    };
+    collected: {
+        [method: string]: AroundHookFunction[];
+    };
+    collectedAll: {
+        before?: AroundHookFunction[];
+        after?: AroundHookFunction[];
+    };
+};
+type HookEnabled = {
+    __hooks: HookStore;
+};
+export declare function convertHookData(input: any): {
+    [method: string]: AroundHookFunction<import("./declarations").Application<any, any>, Service<any, Partial<any>, import("./declarations").Params<import("./declarations").Query>, Partial<Partial<any>>>>[] | HookFunction<import("./declarations").Application<any, any>, Service<any, Partial<any>, import("./declarations").Params<import("./declarations").Query>, Partial<Partial<any>>>>[];
+};
+export declare function collectHooks(target: HookEnabled, method: string): AroundHookFunction<import("./declarations").Application<any, any>, Service<any, Partial<any>, import("./declarations").Params<import("./declarations").Query>, Partial<Partial<any>>>>[];
+export declare function enableHooks(object: any): (this: HookEnabled, input: HookMap<any, any>) => HookEnabled;
+export declare function createContext(service: Service, method: string, data?: HookContextData): HookContext<import("./declarations").Application<any, any>, any>;
+export declare class FeathersHookManager<A> extends HookManager {
+    app: A;
+    method: string;
+    constructor(app: A, method: string);
+    collectMiddleware(self: any, args: any[]): Middleware[];
+    initializeContext(self: any, args: any[], context: HookContext): import("@feathersjs/hooks").HookContext<any, any>;
+    middleware(mw: Middleware[]): this;
+}
+export declare function hookMixin<A>(this: A, service: FeathersService<A>, path: string, options: ServiceOptions): FeathersService<A, Service<any, Partial<any>, import("./declarations").Params<import("./declarations").Query>, Partial<Partial<any>>>>;
+export {};