@ez4/gateway 0.36.0 → 0.37.0

package/dist/main.cjs

@@ -1,19 +1,20 @@
-"use strict";var a=Object.defineProperty;var h=Object.getOwnPropertyDescriptor;var b=Object.getOwnPropertyNames;var W=Object.prototype.hasOwnProperty;var o=(t,e)=>a(t,"name",{value:e,configurable:!0});var v=(t,e)=>{for(var r in e)a(t,r,{get:e[r],enumerable:!0})},H=(t,e,r,n)=>{if(e&&
-typeof e=="object"||typeof e=="function")for(let p of b(e))!W.call(t,p)&&p!==r&&
-a(t,p,{get:()=>e[p],enumerable:!(n=h(e,p))||n.enumerable});return t};var g=t=>H(a({},"__esModule",{value:!0}),t);var q={};v(q,{AuthorizationType:()=>y,Http:()=>R,HttpBadRequestError:()=>i,HttpError:()=>s,
-HttpForbiddenError:()=>m,HttpInternalServerError:()=>l,HttpNotFoundError:()=>u,HttpUnauthorizedError:()=>c,
-HttpUnprocessableEntityError:()=>x,HttpUnsupportedMediaTypeError:()=>d,Ws:()=>f});
-module.exports=g(q);var y=(e=>(e.Bearer="bearer",e))(y||{});var f;(t=>{})(f||={});var R;(t=>{})(R||={});var T=require("@ez4/common");var s=class extends T.ServiceError{constructor(r,n,p){super(n,p);this.status=r}static{
-o(this,"HttpError")}},i=class extends s{static{o(this,"HttpBadRequestError")}constructor(e,r){
-super(400,e||"Bad request",r)}},c=class extends s{static{o(this,"HttpUnauthorize\
-dError")}constructor(e,r){super(401,e||"Unauthorized",r)}},m=class extends s{static{
-o(this,"HttpForbiddenError")}constructor(e,r){super(403,e||"Forbidden",r)}},u=class extends s{static{
-o(this,"HttpNotFoundError")}constructor(e,r){super(404,e||"Not found",r)}},d=class extends s{static{
-o(this,"HttpUnsupportedMediaTypeError")}constructor(e,r){super(415,e||"Unsupport\
-ed media type",r)}},x=class extends s{static{o(this,"HttpUnprocessableEntityErro\
-r")}constructor(e,r){super(422,e||"Unprocessable entity",r)}},l=class extends s{static{
-o(this,"HttpInternalServerError")}constructor(e,r){super(500,e||"Internal server\
- error",r)}};0&&(module.exports={AuthorizationType,Http,HttpBadRequestError,HttpError,HttpForbiddenError,
-HttpInternalServerError,HttpNotFoundError,HttpUnauthorizedError,HttpUnprocessableEntityError,
-HttpUnsupportedMediaTypeError,Ws});
+"use strict";var a=Object.defineProperty;var v=Object.getOwnPropertyDescriptor;var W=Object.getOwnPropertyNames;var A=Object.prototype.hasOwnProperty;var o=(r,e)=>a(r,"name",{value:e,configurable:!0});var g=(r,e)=>{for(var t in e)a(r,t,{get:e[t],enumerable:!0})},H=(r,e,t,n)=>{if(e&&
+typeof e=="object"||typeof e=="function")for(let p of W(e))!A.call(r,p)&&p!==t&&
+a(r,p,{get:()=>e[p],enumerable:!(n=v(e,p))||n.enumerable});return r};var q=r=>H(a({},"__esModule",{value:!0}),r);var b={};g(b,{AuthorizationType:()=>y,Http:()=>h,HttpBadRequestError:()=>i,HttpConflictError:()=>d,
+HttpError:()=>s,HttpForbiddenError:()=>c,HttpInternalServerError:()=>f,HttpNotFoundError:()=>m,
+HttpUnauthorizedError:()=>u,HttpUnprocessableEntityError:()=>l,HttpUnsupportedMediaTypeError:()=>x,
+Ws:()=>R});module.exports=q(b);var y=(e=>(e.Bearer="bearer",e))(y||{});var R;(r=>{})(R||={});var h;(r=>{})(h||={});var T=require("@ez4/common");var s=class extends T.ServiceError{constructor(t,n,p){super(n,p);this.status=t}static{
+o(this,"HttpError")}},i=class extends s{static{o(this,"HttpBadRequestError")}constructor(e,t){
+super(400,e||"Bad request",t)}},u=class extends s{static{o(this,"HttpUnauthorize\
+dError")}constructor(e,t){super(401,e||"Unauthorized",t)}},c=class extends s{static{
+o(this,"HttpForbiddenError")}constructor(e,t){super(403,e||"Forbidden",t)}},m=class extends s{static{
+o(this,"HttpNotFoundError")}constructor(e,t){super(404,e||"Not found",t)}},d=class extends s{static{
+o(this,"HttpConflictError")}constructor(e,t){super(409,e||"Conflict",t)}},x=class extends s{static{
+o(this,"HttpUnsupportedMediaTypeError")}constructor(e,t){super(415,e||"Unsupport\
+ed media type",t)}},l=class extends s{static{o(this,"HttpUnprocessableEntityErro\
+r")}constructor(e,t){super(422,e||"Unprocessable entity",t)}},f=class extends s{static{
+o(this,"HttpInternalServerError")}constructor(e,t){super(500,e||"Internal server\
+ error",t)}};0&&(module.exports={AuthorizationType,Http,HttpBadRequestError,HttpConflictError,
+HttpError,HttpForbiddenError,HttpInternalServerError,HttpNotFoundError,HttpUnauthorizedError,
+HttpUnprocessableEntityError,HttpUnsupportedMediaTypeError,Ws});
 //# sourceMappingURL=main.cjs.map

package/dist/main.mjs

@@ -1,14 +1,16 @@
-var l=Object.defineProperty;var s=(r,e)=>l(r,"name",{value:e,configurable:!0});var p=(e=>(e.Bearer="bearer",e))(p||{});var f;(r=>{})(f||={});var R;(r=>{})(R||={});import{ServiceError as T}from"@ez4/common";var o=class extends T{constructor(t,d,x){super(d,x);this.status=t}static{s(this,
+var f=Object.defineProperty;var s=(r,e)=>f(r,"name",{value:e,configurable:!0});var p=(e=>(e.Bearer="bearer",e))(p||{});var R;(r=>{})(R||={});var h;(r=>{})(h||={});import{ServiceError as T}from"@ez4/common";var o=class extends T{constructor(t,x,l){super(x,l);this.status=t}static{s(this,
 "HttpError")}},n=class extends o{static{s(this,"HttpBadRequestError")}constructor(e,t){
 super(400,e||"Bad request",t)}},a=class extends o{static{s(this,"HttpUnauthorize\
 dError")}constructor(e,t){super(401,e||"Unauthorized",t)}},y=class extends o{static{
 s(this,"HttpForbiddenError")}constructor(e,t){super(403,e||"Forbidden",t)}},i=class extends o{static{
-s(this,"HttpNotFoundError")}constructor(e,t){super(404,e||"Not found",t)}},c=class extends o{static{
+s(this,"HttpNotFoundError")}constructor(e,t){super(404,e||"Not found",t)}},u=class extends o{static{
+s(this,"HttpConflictError")}constructor(e,t){super(409,e||"Conflict",t)}},c=class extends o{static{
 s(this,"HttpUnsupportedMediaTypeError")}constructor(e,t){super(415,e||"Unsupport\
 ed media type",t)}},m=class extends o{static{s(this,"HttpUnprocessableEntityErro\
-r")}constructor(e,t){super(422,e||"Unprocessable entity",t)}},u=class extends o{static{
+r")}constructor(e,t){super(422,e||"Unprocessable entity",t)}},d=class extends o{static{
 s(this,"HttpInternalServerError")}constructor(e,t){super(500,e||"Internal server\
- error",t)}};export{p as AuthorizationType,R as Http,n as HttpBadRequestError,o as HttpError,
-y as HttpForbiddenError,u as HttpInternalServerError,i as HttpNotFoundError,a as HttpUnauthorizedError,
-m as HttpUnprocessableEntityError,c as HttpUnsupportedMediaTypeError,f as Ws};
+ error",t)}};export{p as AuthorizationType,h as Http,n as HttpBadRequestError,u as HttpConflictError,
+o as HttpError,y as HttpForbiddenError,d as HttpInternalServerError,i as HttpNotFoundError,
+a as HttpUnauthorizedError,m as HttpUnprocessableEntityError,c as HttpUnsupportedMediaTypeError,
+R as Ws};
 //# sourceMappingURL=main.mjs.map

package/dist/metadata/auth/handler.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeCallback, TypeFunction, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeCallback, TypeFunction, TypeModel } from '@ez4/reflection';
 import type { AuthHandler } from './types';
 export declare const isAuthHandlerDeclaration: (type: AllType) => type is TypeCallback | TypeFunction;
-export declare const getAuthHandlerMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[], namespace: string) => AuthHandler | undefined;
+export declare const getAuthHandlerMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[], namespace: string) => AuthHandler | undefined;

package/dist/metadata/auth/identity.d.ts

@@ -1,6 +1,6 @@
-import type { AllType, SourceMap, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
-import type { ObjectSchema, UnionSchema } from '@ez4/schema/library';
+import type { AllType, ReflectionTypes, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
+import type { ObjectSchema, UnionSchema } from '@ez4/schema';
 type TypeParent = TypeObject | TypeModel | TypeIntersection;
 export declare const isAuthIdentityDeclaration: (type: TypeModel, namespace: string) => boolean;
-export declare const getAuthIdentityMetadata: (type: AllType, parent: TypeParent, reflection: SourceMap, errorList: Error[], namespace: string) => ObjectSchema | UnionSchema | undefined;
+export declare const getAuthIdentityMetadata: (type: AllType, parent: TypeParent, reflection: ReflectionTypes, errorList: Error[], namespace: string) => ObjectSchema | UnionSchema | undefined;
 export {};

package/dist/metadata/auth/request.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { AuthRequest } from '../auth/types';
 export declare const isAuthRequestDeclaration: (type: TypeModel, namespace: string) => boolean;
-export declare const getAuthRequestMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[], namespace: string) => AuthRequest | undefined;
+export declare const getAuthRequestMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[], namespace: string) => AuthRequest | undefined;

package/dist/metadata/auth/response.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { AuthResponse } from '../auth/types';
 export declare const isAuthResponseDeclaration: (type: TypeModel, namespace: string) => boolean;
-export declare const getAuthResponseMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[], namespace: string) => AuthResponse | undefined;
+export declare const getAuthResponseMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[], namespace: string) => AuthResponse | undefined;

package/dist/metadata/auth/types.d.ts

@@ -1,9 +1,8 @@
+import type { LinkedServices, LinkedVariables } from '@ez4/project/library';
+import type { FunctionSignature } from '@ez4/common/library';
 import type { ObjectSchema, UnionSchema } from '@ez4/schema';
-export type AuthHandler = {
-    name: string;
-    module?: string;
-    file: string;
-    description?: string;
+export type AuthHandler = FunctionSignature & {
+    provider?: AuthProvider;
     response?: AuthResponse;
     request?: AuthRequest;
 };
@@ -15,3 +14,7 @@ export type AuthRequest = {
     parameters?: ObjectSchema;
     query?: ObjectSchema;
 };
+export type AuthProvider = {
+    variables?: LinkedVariables;
+    services?: LinkedServices;
+};

package/dist/metadata/body.d.ts

@@ -0,0 +1,6 @@
+import type { AllType, ReflectionTypes, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
+import type { ArraySchema, ObjectSchema, UnionSchema } from '@ez4/schema';
+type TypeParent = TypeObject | TypeModel | TypeIntersection;
+export declare const isWebBodyDeclaration: (type: TypeModel, namespace: string) => boolean;
+export declare const getWebBodyMetadata: (type: AllType, parent: TypeParent, reflection: ReflectionTypes, errorList: Error[], namespace: string) => ObjectSchema | UnionSchema | ArraySchema | import("@ez4/schema").BooleanSchema | import("@ez4/schema").NumberSchema | import("@ez4/schema").StringSchema | undefined;
+export {};

package/dist/metadata/headers.d.ts

@@ -0,0 +1,5 @@
+import type { AllType, ReflectionTypes, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
+type TypeParent = TypeObject | TypeModel | TypeIntersection;
+export declare const isWebHeadersDeclaration: (type: TypeModel, namespace: string) => boolean;
+export declare const getWebHeadersMetadata: (type: AllType, parent: TypeParent, reflection: ReflectionTypes, errorList: Error[], namespace: string) => import("@ez4/schema").ObjectSchema | undefined;
+export {};

package/dist/metadata/http/access.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { HttpAccess } from './types';
 export declare const isHttpAccessDeclaration: (type: TypeModel) => boolean;
-export declare const getHttpAccessMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpAccess | undefined;
+export declare const getHttpAccessMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => HttpAccess | undefined;

package/dist/metadata/http/authorization.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { HttpAuthorization } from './types';
 export declare const isHttpAuthorizationDeclaration: (type: TypeModel) => boolean;
-export declare const getHttpAuthorizationMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpAuthorization | undefined;
+export declare const getHttpAuthorizationMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => HttpAuthorization | undefined;

package/dist/metadata/http/cache.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { HttpCache } from './types';
 export declare const isHttpCacheDeclaration: (type: TypeModel) => boolean;
-export declare const getHttpCacheMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpCache | undefined;
+export declare const getHttpCacheMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => HttpCache | undefined;

package/dist/metadata/http/cors.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { HttpCors } from './types';
 export declare const isHttpCorsDeclaration: (type: TypeModel) => boolean;
-export declare const getHttpCorsMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpCors | undefined;
+export declare const getHttpCorsMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => HttpCors | undefined;

package/dist/metadata/http/defaults.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import { type HttpDefaults } from './types';
 export declare const isHttpDefaultsDeclaration: (type: TypeModel) => boolean;
-export declare const getHttpDefaultsMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpDefaults | undefined;
+export declare const getHttpDefaultsMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => HttpDefaults | undefined;

package/dist/metadata/http/errors.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, ModelProperty, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ModelProperty, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { HttpErrors } from './types';
-export declare const getHttpErrorsMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpErrors | undefined;
-export declare const getErrorClasses: (member: ModelProperty, errorCode: number, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpErrors;
+export declare const getHttpErrorsMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => HttpErrors | undefined;
+export declare const getErrorClasses: (member: ModelProperty, errorCode: number, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => HttpErrors;

package/dist/metadata/http/handler.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeCallback, TypeFunction, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeCallback, TypeFunction, TypeModel } from '@ez4/reflection';
 import type { HttpHandler } from './types';
 export declare const isHttpHandlerDeclaration: (type: AllType) => type is TypeCallback | TypeFunction;
-export declare const getHttpHandlerMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[], external: boolean) => HttpHandler | undefined;
+export declare const getHttpHandlerMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[], external: boolean) => HttpHandler | undefined;

package/dist/metadata/http/import.d.ts

@@ -1,7 +1,7 @@
-import type { AllType, SourceMap, TypeClass } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeClass } from '@ez4/reflection';
 import type { HttpImport } from './types';
 export declare const isHttpImportDeclaration: (type: AllType) => type is TypeClass;
-export declare const getHttpImportsMetadata: (reflection: SourceMap) => {
+export declare const getHttpImportsMetadata: (reflection: ReflectionTypes) => {
     services: Record<string, HttpImport>;
     errors: Error[];
 };

package/dist/metadata/http/request.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { HttpRequest } from './types';
 export declare const isHttpRequestDeclaration: (type: TypeModel) => boolean;
-export declare const getHttpRequestMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpRequest | undefined;
+export declare const getHttpRequestMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => HttpRequest | undefined;

package/dist/metadata/http/response.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { HttpResponse } from './types';
 export declare const isHttpResponseDeclaration: (type: TypeModel) => boolean;
-export declare const getHttpResponseMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => HttpResponse | undefined;
+export declare const getHttpResponseMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => HttpResponse | undefined;

package/dist/metadata/http/routes.d.ts

@@ -1,5 +1,5 @@
-import type { AllType, ModelProperty, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ModelProperty, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { HttpRoute } from './types';
 export declare const isHttpRouteDeclaration: (type: AllType) => type is TypeModel;
-export declare const getHttpLocalRoutes: (parent: TypeModel, member: ModelProperty, reflection: SourceMap, errorList: Error[]) => HttpRoute[] | undefined;
-export declare const getHttpRemoteRoutes: (parent: TypeModel, member: ModelProperty, reflection: SourceMap, errorList: Error[]) => HttpRoute[] | undefined;
+export declare const getHttpLocalRoutes: (parent: TypeModel, member: ModelProperty, reflection: ReflectionTypes, errorList: Error[]) => HttpRoute[] | undefined;
+export declare const getHttpRemoteRoutes: (parent: TypeModel, member: ModelProperty, reflection: ReflectionTypes, errorList: Error[]) => HttpRoute[] | undefined;

package/dist/metadata/http/service.d.ts

@@ -1,7 +1,7 @@
-import type { AllType, SourceMap, TypeClass } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeClass } from '@ez4/reflection';
 import type { HttpService } from './types';
 export declare const isHttpServiceDeclaration: (type: AllType) => type is TypeClass;
-export declare const getHttpServicesMetadata: (reflection: SourceMap) => {
+export declare const getHttpServicesMetadata: (reflection: ReflectionTypes) => {
     services: Record<string, HttpService>;
     errors: Error[];
 };

package/dist/metadata/http/types.d.ts

@@ -1,17 +1,15 @@
 import type { ArraySchema, NamingStyle, ObjectSchema, ScalarSchema, UnionSchema } from '@ez4/schema';
+import type { FunctionSignature, ServiceListener } from '@ez4/common/library';
 import type { LinkedServices, LinkedVariables } from '@ez4/project/library';
 import type { ServiceMetadata } from '@ez4/project/library';
-import type { ServiceListener } from '@ez4/common/library';
 import type { AuthorizationType } from '../../services/http/authorization';
-import type { AuthHandler } from '../auth/types';
 import type { HttpPath } from '../../services/http/path';
+import type { AuthHandler } from '../auth/types';
 export declare const HttpServiceType = "@ez4/http";
 export declare const HttpImportType = "@ez4/import:http";
 export declare const HttpNamespaceType = "Http";
-export declare const isHttpService: (service: ServiceMetadata) => service is HttpService;
-export declare const isHttpImport: (service: ServiceMetadata) => service is HttpImport;
 export type HttpDataSchema = ObjectSchema | UnionSchema | ArraySchema | ScalarSchema;
-export type HttpService = ServiceMetadata & {
+export type HttpService = Omit<ServiceMetadata, 'variables' | 'services'> & Required<Pick<ServiceMetadata, 'variables' | 'services'>> & {
     type: typeof HttpServiceType;
     displayName?: string;
     description?: string;
@@ -51,14 +49,10 @@ export type HttpResponse = {
     headers?: ObjectSchema;
     body?: HttpDataSchema;
 };
-export type HttpHandler = {
-    name: string;
-    file: string;
-    module?: string;
-    description?: string;
+export type HttpHandler = FunctionSignature & {
+    provider?: HttpProvider;
     response: HttpResponse;
     request?: HttpRequest;
-    provider?: HttpProvider;
 };
 export type HttpErrors = {
     [name: string]: number;
@@ -104,3 +98,20 @@ export type HttpProvider = {
     variables?: LinkedVariables;
     services?: LinkedServices;
 };
+export declare const isHttpService: (service: ServiceMetadata) => service is HttpService;
+export declare const createHttpService: (name: string) => {
+    variables: {};
+    services: {};
+    type: "@ez4/http";
+    name: string;
+    context: Record<string, import("@ez4/project/library").LinkedContext>;
+    displayName?: string | null | undefined;
+    description?: string | null | undefined;
+    defaults?: HttpDefaults | null | undefined;
+    routes?: HttpRoute[] | null | undefined;
+    cache?: HttpCache | null | undefined;
+    access?: HttpAccess | null | undefined;
+    cors?: HttpCors | null | undefined;
+};
+export declare const isHttpImport: (service: ServiceMetadata) => service is HttpImport;
+export declare const createHttpImport: (name: string) => ServiceMetadata & import("@ez4/utils").Incomplete<HttpImport>;

package/dist/metadata/parameters.d.ts

@@ -0,0 +1,5 @@
+import type { AllType, ReflectionTypes, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
+type TypeParent = TypeObject | TypeModel | TypeIntersection;
+export declare const isWebParametersDeclaration: (type: TypeModel, namespace: string) => boolean;
+export declare const getWebParametersMetadata: (type: AllType, parent: TypeParent, reflection: ReflectionTypes, errorList: Error[], namespace: string) => import("@ez4/schema").ObjectSchema | undefined;
+export {};

package/dist/metadata/{web/preferences.d.ts → preferences.d.ts}

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { WebPreferences } from './types';
 export declare const isWebPreferencesDeclaration: (type: TypeModel, namespace: string) => boolean;
-export declare const getWebPreferencesMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[], namespace: string) => WebPreferences | undefined;
+export declare const getWebPreferencesMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[], namespace: string) => WebPreferences | undefined;

package/dist/metadata/provider.d.ts

@@ -0,0 +1,4 @@
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
+import type { HttpProvider } from './http/types';
+export declare const isWebProviderDeclaration: (type: AllType, namespace: string) => type is TypeModel;
+export declare const getWebProviderMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[], namespace: string) => HttpProvider | undefined;

package/dist/metadata/query.d.ts

@@ -0,0 +1,5 @@
+import type { AllType, ReflectionTypes, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
+type TypeParent = TypeObject | TypeModel | TypeIntersection;
+export declare const isWebQueryDeclaration: (type: TypeModel, namespace: string) => boolean;
+export declare const getWebQueryMetadata: (type: AllType, parent: TypeParent, reflection: ReflectionTypes, errorList: Error[], namespace: string) => import("@ez4/schema").ObjectSchema | undefined;
+export {};

package/dist/metadata/utils/{type.d.ts → name.d.ts}

@@ -1 +1,2 @@
 export declare const getFullTypeName: (namespace: string, type: string) => string;
+export declare const getValidatorName: (type: string) => string;

package/dist/metadata/utils/provider.d.ts

@@ -0,0 +1,4 @@
+import type { LinkedServices } from '@ez4/project/library';
+import type { AuthHandler } from '../auth/types';
+import type { HttpHandler } from '../http/types';
+export declare const attachProviderLinkedServices: (handler: HttpHandler | AuthHandler, services: LinkedServices, errorList: Error[], fileName?: string) => void;

package/dist/metadata/utils/schema.d.ts

@@ -1,3 +1,3 @@
-import type { SourceMap, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
-export declare const getSchemaFromIntersection: (type: TypeObject | TypeModel | TypeIntersection, reflection: SourceMap) => import("@ez4/schema").ObjectSchema | undefined;
-export declare const getSchemaFromObject: (type: TypeObject | TypeModel | TypeIntersection, reflection: SourceMap) => import("@ez4/schema").ObjectSchema | undefined;
+import type { ReflectionTypes, TypeIntersection, TypeModel, TypeObject } from '@ez4/reflection';
+export declare const getSchemaFromIntersection: (type: TypeObject | TypeModel | TypeIntersection, reflection: ReflectionTypes) => import("@ez4/schema").ObjectSchema | undefined;
+export declare const getSchemaFromObject: (type: TypeObject | TypeModel | TypeIntersection, reflection: ReflectionTypes) => import("@ez4/schema").ObjectSchema | undefined;

package/dist/metadata/utils/validator.d.ts

@@ -0,0 +1,5 @@
+import type { LinkedServices } from '@ez4/project/library';
+import type { AuthHandler } from '../auth/types';
+import type { HttpHandler } from '../http/types';
+import type { WsHandler } from '../ws/types';
+export declare const attachValidatorLinkedServices: (handler: HttpHandler | AuthHandler | WsHandler, services: LinkedServices) => void;

package/dist/metadata/ws/connection.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeClass, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeClass, TypeModel } from '@ez4/reflection';
 import type { WsConnection } from './types';
 export declare const isWsConnectionDeclaration: (type: AllType) => type is TypeClass;
-export declare const getWsConnectionMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsConnection | undefined;
+export declare const getWsConnectionMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => WsConnection | undefined;

package/dist/metadata/ws/defaults.d.ts

@@ -1,5 +1,5 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { WsDefaults } from './types';
 export declare const FULL_BASE_TYPE: string;
 export declare const isWsDefaultsDeclaration: (type: TypeModel) => boolean;
-export declare const getWsDefaultsMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsDefaults | undefined;
+export declare const getWsDefaultsMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => WsDefaults | undefined;

package/dist/metadata/ws/event.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { WsEvent } from './types';
 export declare const isWsEventDeclaration: (type: TypeModel) => boolean;
-export declare const getWsEventMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsEvent | undefined;
+export declare const getWsEventMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => WsEvent | undefined;

package/dist/metadata/ws/handlers.d.ts

@@ -1,5 +1,4 @@
-import type { AllType, TypeCallback, TypeFunction, TypeModel, SourceMap } from '@ez4/reflection';
-import type { WsHandler } from './types';
+import type { AllType, TypeCallback, TypeFunction, TypeModel, ReflectionTypes } from '@ez4/reflection';
 export declare const isWsHandlerDeclaration: (type: AllType) => type is TypeCallback | TypeFunction;
-export declare const getWsConnectionHandler: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsHandler | undefined;
-export declare const getWsMessageHandler: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsHandler | undefined;
+export declare const getWsConnectionHandler: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => import("@ez4/common/library").FunctionSignature | undefined;
+export declare const getWsMessageHandler: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => import("@ez4/common/library").FunctionSignature | undefined;

package/dist/metadata/ws/message.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeClass, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeClass, TypeModel } from '@ez4/reflection';
 import type { WsMessage } from './types';
 export declare const isWsMessageDeclaration: (type: AllType) => type is TypeClass;
-export declare const getWsMessageMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsMessage | undefined;
+export declare const getWsMessageMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => WsMessage | undefined;

package/dist/metadata/ws/request.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { WsRequest } from './types';
 export declare const isWsRequestDeclaration: (type: TypeModel) => boolean;
-export declare const getWsRequestMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsRequest | undefined;
+export declare const getWsRequestMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => WsRequest | undefined;

package/dist/metadata/ws/response.d.ts

@@ -1,4 +1,4 @@
-import type { AllType, SourceMap, TypeModel } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeModel } from '@ez4/reflection';
 import type { WsResponse } from './types';
 export declare const isWsResponseDeclaration: (type: TypeModel) => boolean;
-export declare const getWsResponseMetadata: (type: AllType, parent: TypeModel, reflection: SourceMap, errorList: Error[]) => WsResponse | undefined;
+export declare const getWsResponseMetadata: (type: AllType, parent: TypeModel, reflection: ReflectionTypes, errorList: Error[]) => WsResponse | undefined;

package/dist/metadata/ws/service.d.ts

@@ -1,7 +1,7 @@
-import type { AllType, SourceMap, TypeClass } from '@ez4/reflection';
+import type { AllType, ReflectionTypes, TypeClass } from '@ez4/reflection';
 import type { WsService } from './types';
 export declare const isWsServiceDeclaration: (type: AllType) => type is TypeClass;
-export declare const getWsServicesMetadata: (reflection: SourceMap) => {
+export declare const getWsServicesMetadata: (reflection: ReflectionTypes) => {
     services: Record<string, WsService>;
     errors: Error[];
 };

package/dist/metadata/ws/types.d.ts

@@ -1,12 +1,11 @@
 import type { ArraySchema, NamingStyle, ObjectSchema, ScalarSchema, UnionSchema } from '@ez4/schema';
 import type { LinkedVariables, ServiceMetadata } from '@ez4/project/library';
-import type { ServiceListener } from '@ez4/common/library';
+import type { FunctionSignature, ServiceListener } from '@ez4/common/library';
 import type { AuthHandler } from '../auth/types';
 export declare const WsServiceType = "@ez4/ws";
 export declare const WsNamespaceType = "Ws";
-export declare const isWsService: (service: ServiceMetadata) => service is WsService;
 export type WsDataSchema = ObjectSchema | UnionSchema | ArraySchema | ScalarSchema;
-export type WsService = ServiceMetadata & {
+export type WsService = Omit<ServiceMetadata, 'variables' | 'services'> & Required<Pick<ServiceMetadata, 'variables' | 'services'>> & {
     type: typeof WsServiceType;
     displayName?: string;
     stageName?: string;
@@ -36,11 +35,7 @@ export type WsMessage = {
     timeout?: number;
     memory?: number;
 };
-export type WsHandler = {
-    name: string;
-    file: string;
-    module?: string;
-    description?: string;
+export type WsHandler = FunctionSignature & {
     request?: WsRequest | WsEvent;
     response?: WsResponse;
 };
@@ -70,3 +65,19 @@ export type WsDefaults = {
 export type WsCache = {
     authorizerTTL?: number;
 };
+export declare const isWsService: (service: ServiceMetadata) => service is WsService;
+export declare const createWsService: (name: string) => {
+    variables: {};
+    services: {};
+    type: "@ez4/ws";
+    name: string;
+    context: Record<string, import("@ez4/project/library").LinkedContext>;
+    displayName?: string | null | undefined;
+    stageName?: string | null | undefined;
+    description?: string | null | undefined;
+    defaults?: WsDefaults | null | undefined;
+    schema?: WsDataSchema | null | undefined;
+    connect?: WsConnection | null | undefined;
+    disconnect?: WsConnection | null | undefined;
+    message?: WsMessage | null | undefined;
+};

package/dist/services/auth/request.d.ts

@@ -1,6 +1,6 @@
-import type { WebPathParameters } from '../web/parameters';
-import type { WebQueryStrings } from '../web/query';
-import type { WebHeaders } from '../web/headers';
+import type { WebPathParameters } from '../parameters';
+import type { WebQueryStrings } from '../query';
+import type { WebHeaders } from '../headers';
 /**
  * Authorization request.
  */

package/dist/services/errors.d.ts

@@ -30,6 +30,12 @@ export declare class HttpForbiddenError extends HttpError {
 export declare class HttpNotFoundError extends HttpError {
     constructor(message?: string, details?: string[]);
 }
+/**
+ * HTTP Conflict error.
+ */
+export declare class HttpConflictError extends HttpError {
+    constructor(message?: string, details?: string[]);
+}
 /**
  * HTTP Unsupported Media Type error.
  */

package/dist/services/http/contract.d.ts

@@ -1,14 +1,15 @@
 import type { Service as CommonService } from '@ez4/common';
 import type { LinkedVariables } from '@ez4/project/library';
+import type { AuthProvider as HttpAuthProvider } from '../auth/provider';
 import type { AuthResponse as HttpAuthResponse } from '../auth/response';
 import type { AuthRequest as HttpAuthRequest } from '../auth/request';
-import type { WebJsonBody, WebRawBody } from '../web/body';
-import type { WebPathParameters } from '../web/parameters';
-import type { WebPreferences } from '../web/preferences';
 import type { AuthIdentity } from '../auth/identity';
-import type { WebQueryStrings } from '../web/query';
-import type { WebHeaders } from '../web/headers';
 import type { AuthCache } from '../auth/cache';
+import type { WebHeaders } from '../headers';
+import type { WebQueryStrings } from '../query';
+import type { WebPreferences } from '../preferences';
+import type { WebPathParameters } from '../parameters';
+import type { WebJsonBody, WebRawBody } from '../body';
 import type { HttpSuccessStatuses, HttpSuccessEmptyResponse, HttpSuccessResponse, HttpEmptyRequest } from './utils';
 import type { HttpAuthorization } from './authorization';
 import type { HttpDefaults } from './defaults';
@@ -39,10 +40,11 @@ export declare namespace Http {
     type Cache = AuthCache;
     type Request = HttpRequest;
     type Response = HttpResponse;
+    type Provider = HttpProvider;
     type AuthRequest = HttpAuthRequest;
     type AuthResponse = HttpAuthResponse;
+    type AuthProvider = HttpAuthProvider;
     type Errors = HttpErrors;
-    type Provider = HttpProvider;
     type Cors = HttpCors;
     type Incoming<T extends Request> = HttpIncoming<T>;
     type Listener<T extends Request> = HttpListener<T>;

package/dist/services/http/defaults.d.ts

@@ -1,4 +1,4 @@
-import type { WebDefaults } from '../web/defaults';
+import type { WebDefaults } from '../defaults';
 import type { HttpListener } from './listener';
 import type { HttpRequest } from './request';
 import type { HttpErrors } from './errors';

package/dist/services/http/request.d.ts

@@ -1,8 +1,8 @@
 import type { AuthIdentity } from '../auth/identity';
-import type { WebPathParameters } from '../web/parameters';
-import type { WebQueryStrings } from '../web/query';
-import type { WebHeaders } from '../web/headers';
-import type { WebBody } from '../web/body';
+import type { WebPathParameters } from '../parameters';
+import type { WebQueryStrings } from '../query';
+import type { WebHeaders } from '../headers';
+import type { WebBody } from '../body';
 /**
  * HTTP request.
  */

package/dist/services/http/response.d.ts

@@ -1,5 +1,5 @@
-import type { WebHeaders } from '../web/headers';
-import type { WebBody } from '../web/body';
+import type { WebHeaders } from '../headers';
+import type { WebBody } from '../body';
 /**
  * HTTP response.
  */

package/dist/services/http/route.d.ts

@@ -1,6 +1,6 @@
 import type { AuthHandler } from '../auth/handler';
 import type { AuthRequest } from '../auth/request';
-import type { WebTarget } from '../web/target';
+import type { WebTarget } from '../target';
 import type { HttpListener } from './listener';
 import type { HttpRequest } from './request';
 import type { HttpHandler } from './handler';