@opra/common 0.22.0 → 0.23.1

package/esm/{url → http}/opra-url.js

@@ -1,47 +1,36 @@
 var _a;
 import { splitString, tokenize } from 'fast-tokenizer';
-import { HttpParams } from '../http/index.js';
-import { normalizePath } from '../utils/path-utils.js';
 import { OpraURLPath } from './opra-url-path.js';
-import { decodePathComponent } from './utils/decode-path-component.js';
 const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
 const urlRegEx = /^(?:((?:[A-Z][A-Z+-.]+:)+)\/\/([^/?]+))?(.*)?$/i;
 const schemeRegEx = /^([A-Z][A-Z+-.]+:?)+$/i;
 const hostRegEx = /^([^/:]+)(?::(\d+))?$/;
 const hostnameRegEx = /^([^/:]+)$/;
-const kContext = Symbol('kContext');
-const kPath = Symbol('kPath');
-const kParams = Symbol('kParams');
+const kContext = Symbol.for('kContext');
+const kPath = Symbol.for('kPath');
+const kSearchParams = Symbol.for('kSearchParams');
 export class OpraURL {
     constructor(input, base) {
         this[_a] = {
             protocol: '',
             username: '',
-            prefix: '',
             hostname: '',
             port: '',
             hash: '',
             password: ''
         };
-        this[kPath] = new OpraURLPath('', {
-            onChange: () => {
-                this[kContext].pathname = undefined;
-                this[kContext].address = undefined;
-            }
-        });
-        this[kParams] = new HttpParams('', {
-            onChange: () => {
-                this[kContext].search = undefined;
-            }
-        });
+        this[kSearchParams] = new URLSearchParams();
+        this[kPath] = new OpraURLPath();
         if (input)
-            this.parse(typeof input === 'object' ? input.toString() : input);
-        if (base) {
+            this._parse(String(input));
+        if (base && !this.host) {
             const baseUrl = base instanceof OpraURL ? base : new OpraURL(base);
             this[kContext].protocol = baseUrl.protocol;
             this[kContext].hostname = baseUrl.hostname;
+            this[kContext].username = baseUrl.username;
+            this[kContext].password = baseUrl.password;
             this[kContext].port = baseUrl.port;
-            this[kContext].prefix = baseUrl.pathname;
+            this.path = OpraURLPath.join(baseUrl.path, this.path);
         }
     }
     get address() {
@@ -55,7 +44,6 @@ export class OpraURL {
                         : '') + this.host;
             }
             this[kContext].address = address +
-                (this.prefix !== '/' ? this.prefix : '') +
                 (this.pathname !== '/' ? this.pathname : '');
         }
         return this[kContext].address;
@@ -93,7 +81,7 @@ export class OpraURL {
         }
         else
             this[kContext].hostname = '';
-        this[kContext].address = undefined;
+        this.invalidate();
     }
     get href() {
         return this.address + this.search + this.hash;
@@ -103,7 +91,7 @@ export class OpraURL {
     }
     set password(v) {
         this[kContext].password = v ?? '';
-        this[kContext].address = undefined;
+        this.invalidate();
     }
     get port() {
         return this[kContext].port;
@@ -112,8 +100,8 @@ export class OpraURL {
         if (value) {
             // noinspection SuspiciousTypeOfGuard
             const v = typeof value === 'number' ? value : parseInt(value, 10);
-            if (isNaN(v) || v < 1 || v > 35535 || v % 1 > 0)
-                throw Object.assign(new TypeError('Invalid port'), {
+            if (isNaN(v) || v < 1 || v > 65535 || v % 1 > 0)
+                throw Object.assign(new TypeError(`Invalid port number (${value})`), {
                     hostname: v,
                     code: 'ERR_INVALID_URL'
                 });
@@ -121,18 +109,7 @@ export class OpraURL {
         }
         else
             this[kContext].port = '';
-    }
-    get prefix() {
-        return this[kContext].prefix;
-    }
-    set prefix(value) {
-        if (value) {
-            const url = new OpraURL(value);
-            this[kContext].prefix = url.pathname;
-        }
-        else
-            this[kContext].prefix = '';
-        this[kContext].address = undefined;
+        this.invalidate();
     }
     get protocol() {
         return this[kContext].protocol;
@@ -148,14 +125,14 @@ export class OpraURL {
         }
         else
             this[kContext].protocol = '';
-        this[kContext].address = undefined;
+        this.invalidate();
     }
     get username() {
         return this[kContext].username;
     }
     set username(v) {
         this[kContext].username = v ?? '';
-        this[kContext].address = undefined;
+        this.invalidate();
     }
     get origin() {
         return this.hostname ? (this.protocol + '//' + this.hostname) : '';
@@ -163,13 +140,20 @@ export class OpraURL {
     get path() {
         return this[kPath];
     }
+    set path(path) {
+        // noinspection SuspiciousTypeOfGuard
+        this[kPath] = path instanceof OpraURLPath ? path : new OpraURLPath(path);
+        this[kContext].pathname = String(this[kPath]);
+        this.invalidate();
+    }
     get pathname() {
         if (this[kContext].pathname == null)
-            this[kContext].pathname = '/' + this[kPath].toString();
+            this[kContext].pathname = this.path.toString() || '/';
         return this[kContext].pathname;
     }
     set pathname(v) {
-        this._setPathname(v, false);
+        this[kPath] = new OpraURLPath(v);
+        this.invalidate();
     }
     get hash() {
         return this[kContext].hash;
@@ -178,23 +162,36 @@ export class OpraURL {
         this[kContext].hash = v ? (v.startsWith('#') ? v : '#' + v) : '';
     }
     get search() {
-        if (this[kContext].search == null) {
-            const s = this[kParams].toString();
-            this[kContext].search = s ? ('?' + s) : '';
-        }
-        return this[kContext].search;
+        const s = this[kSearchParams].toString();
+        return s ? '?' + s : '';
     }
     set search(v) {
-        if (v) {
-            this[kParams].clear();
-            this[kParams].appendAll(v);
-        }
-        this[kContext].search = undefined;
+        this[kSearchParams] = new URLSearchParams(v);
     }
     get searchParams() {
-        return this[kParams];
+        return this[kSearchParams];
+    }
+    set setSearchParams(v) {
+        this[kSearchParams] = v;
+    }
+    invalidate() {
+        this[kContext].address = undefined;
+        this[kContext].pathname = undefined;
+    }
+    join(...items) {
+        this.path = this.path.join(...items);
+        this.invalidate();
+        return this;
+    }
+    resolve(...items) {
+        this.path = this.path.resolve(...items);
+        this.invalidate();
+        return this;
     }
-    parse(input) {
+    toString() {
+        return this.href;
+    }
+    _parse(input) {
         const m = urlRegEx.exec(input);
         if (!m)
             throw Object.assign(new TypeError('Invalid URL'), {
@@ -224,16 +221,9 @@ export class OpraURL {
         input = tokenizer.next() || '';
         this.hash = tokenizer.join('#');
         tokenizer = tokenize(input, { delimiters: '?', quotes: true, brackets: true });
-        this._setPathname(tokenizer.next() || '', isAbsolute);
+        this.path = new OpraURLPath(tokenizer.next());
         this.search = tokenizer.join('&');
     }
-    join(...source) {
-        this.path.join(...source);
-        return this;
-    }
-    toString() {
-        return this.href;
-    }
     /* istanbul ignore next */
     [(_a = kContext, nodeInspectCustom)]() {
         // this._update();
@@ -244,59 +234,13 @@ export class OpraURL {
             host: this.host,
             hostname: this.hostname,
             origin: this.origin,
-            pathPrefix: this.prefix,
             path: this.path,
             pathname: this.pathname,
             search: this.search,
             hash: this.hash,
         };
     }
-    //
-    // protected _update() {
-    //   if (!this[kContext].needUpdate)
-    //     return;
-    //   const ctx = this[kContext];
-    //   ctx.needUpdate = false;
-    //   let s = this.path.toString();
-    //   ctx.pathname = s ? '/' + s : '';
-    //   s = this.searchParams.toString();
-    //   ctx.search = s ? '?' + s : '';
-    //
-    //   let address = '';
-    //   if (ctx.hostname) {
-    //     address += (ctx.protocol || 'http:') + '//' +
-    //         (ctx.username || ctx.password
-    //             ? (
-    //                 (ctx.username ? encodeURIComponent(ctx.username) : '') +
-    //                 (ctx.password ? ':' + encodeURIComponent(ctx.password) : '') + '@'
-    //             )
-    //             : '') + this.host;
-    //   }
-    //   ctx.address = address + ctx.prefix + ctx.pathname;
-    // }
-    _setPathname(v, trimPrefix) {
-        this.path.clear();
-        if (!v)
-            return;
-        const pathTokenizer = tokenize(normalizePath(v, true), {
-            delimiters: '/', quotes: true, brackets: true,
-        });
-        if (trimPrefix && this.prefix) {
-            const prefixTokenizer = tokenize(normalizePath(this.prefix, true), {
-                delimiters: '/', quotes: true, brackets: true,
-            });
-            for (const a of prefixTokenizer) {
-                const b = pathTokenizer.next();
-                if (a !== b)
-                    throw Object.assign(new Error('Invalid URL path. pathPrefix does not match'), { path: v, code: 'ERR_INVALID_URL_PATH' });
-            }
-        }
-        for (const x of pathTokenizer) {
-            const p = decodePathComponent(x);
-            this.path.join(p);
-        }
-    }
 }
 OpraURL.kContext = kContext;
 OpraURL.kPath = kPath;
-OpraURL.kParams = kParams;
+OpraURL.kParams = kSearchParams;

package/esm/i18n/i18n.js

@@ -2,7 +2,7 @@ import { splitString, tokenize } from 'fast-tokenizer';
 import fs from 'fs';
 import path from 'path';
 import i18next from '@browsery/i18next';
-import { isUrl } from '../helpers/index.js';
+import { isUrlString } from '../helpers/index.js';
 import { unescapeString } from './string-utils.js';
 export const BaseI18n = Object.getPrototypeOf(i18next).constructor;
 const globalLocaleDirs = [];
@@ -54,7 +54,7 @@ export class I18n extends BaseI18n {
     }
     async loadResourceBundle(lang, ns, filePath, deep, overwrite) {
         let obj;
-        if (isUrl(filePath)) {
+        if (isUrlString(filePath)) {
             obj = (await fetch(filePath, { headers: { accept: 'application/json' } })).json();
         }
         else {

package/esm/index.js

@@ -6,6 +6,4 @@ export * from './helpers/index.js';
 export * from './http/index.js';
 export * from './i18n/index.js';
 export * from './schema/index.js';
-export * from './url/index.js';
-export * from './utils/path-utils.js';
 export { uid } from 'uid';

package/esm/schema/opra-schema.ns.js

@@ -7,7 +7,7 @@ export * from './data-type/mapped-type.interface.js';
 export * from './data-type/union-type.interface.js';
 export * from './resource/collection.interface.js';
 export * from './resource/container.interface.js';
-export * from './resource/endpoint.interface.js';
+export * from './resource/operation.interface.js';
 export * from './resource/resource.interface.js';
 export * from './resource/singleton.interface.js';
 export * from './resource/storage.interface.js';

package/esm/schema/resource/operation.interface.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",
@@ -49,20 +49,20 @@
     "lodash.omit": "^4.5.0",
     "putil-isplainobject": "^1.1.5",
     "putil-merge": "^3.10.3",
-    "putil-promisify": "^1.10.0",
+    "putil-promisify": "^1.10.1",
     "putil-varhelpers": "^1.6.5",
     "reflect-metadata": "^0.1.13",
     "uid": "^2.0.1",
-    "valgen": "^4.0.0-alpha.6"
+    "valgen": "^4.0.0"
   },
   "devDependencies": {
     "@browsery/fs": "^0.4.0",
     "@browsery/stream": "^0.5.0",
     "@browsery/util": "^0.4.0",
     "@types/encodeurl": "^1.0.0",
-    "@types/validator": "^13.7.17",
+    "@types/validator": "^13.11.1",
     "path-browserify": "^1.0.1",
-    "ts-gems": "^2.4.0"
+    "ts-gems": "^2.4.1"
   },
   "engines": {
     "node": ">=16.0",

package/types/document/api-document.d.ts

@@ -12,6 +12,7 @@ export declare class ApiDocument {
     protected _designCtorMap: Map<Function | Type<any>, string>;
     protected _typeCache: ResponsiveMap<DataType>;
     protected _typesCacheByCtor: Map<object | Type<any>, DataType>;
+    protected _metadataCache?: OpraSchema.ApiDocument;
     url?: string;
     info: OpraSchema.DocumentInfo;
     references: ResponsiveMap<ApiDocument>;
@@ -91,6 +92,8 @@ export declare class ApiDocument {
     /**
      * Export as Opra schema definition object
      */
-    exportSchema(): OpraSchema.ApiDocument;
+    exportSchema(options?: {
+        webSafe?: boolean;
+    }): OpraSchema.ApiDocument;
     invalidate(): void;
 }

package/types/document/data-type/complex-type.d.ts

@@ -6,13 +6,14 @@ import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
 import { ApiField } from './api-field.js';
 import { DataType } from './data-type.js';
+import type { MappedType } from './mapped-type.js';
 import type { UnionType } from './union-type.js';
 /**
  * @namespace ComplexType
  */
 export declare namespace ComplexType {
     interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.ComplexType, 'ctor' | 'abstract' | 'additionalFields'> {
-        base?: ComplexType | UnionType;
+        base?: ComplexType;
     }
     interface OwnProperties extends Readonly<StrictOmit<OpraSchema.ComplexType, 'fields'>> {
         fields: ResponsiveMap<ApiField>;
@@ -28,30 +29,24 @@ export declare namespace ComplexType {
  * @class ComplexType
  */
 declare class ComplexTypeClass extends DataType {
+    protected _decode: vg.Validator<any, any>;
+    protected _encode: vg.Validator<any, any>;
     readonly kind = "ComplexType";
     readonly ctor: Type;
-    readonly base?: ComplexType | UnionType;
+    readonly base?: ComplexType | UnionType | MappedType;
     readonly own: ComplexType.OwnProperties;
     readonly fields: ResponsiveMap<ApiField>;
     readonly abstract?: boolean;
-    readonly additionalFields?: boolean | vg.Validator<any, any> | 'ignore';
-    protected _decoder?: vg.Validator<any, any>;
-    protected _encoder?: vg.Validator<any, any>;
+    readonly additionalFields?: boolean | vg.Validator | 'error';
     constructor(document: ApiDocument, init: ComplexType.InitArguments);
     addField(init: ApiField.InitArguments): ApiField;
     findField(nameOrPath: string): ApiField | undefined;
     getField(nameOrPath: string): ApiField;
     iteratePath(path: string, silent?: boolean): IterableIterator<[string, ApiField | undefined, string]>;
-    normalizeFieldPath(fieldPath: string): string;
-    normalizeFieldPath(fieldPaths: string[]): string[];
+    normalizeFieldPath(fieldPaths: string | string[]): string[] | undefined;
     exportSchema(): OpraSchema.ComplexType;
     isTypeOf(t: Type | Function): boolean;
     extendsFrom(t: string | Type | DataType): boolean;
-    decode(v: object): any;
-    encode(v: any): any;
-    validate(v: any): any;
-    protected _getDecoder(): vg.Validator<any, any>;
-    protected _getEncoder(): vg.Validator<any, any>;
 }
 /**
  * Callable class pattern for ComplexType

package/types/document/data-type/data-type.d.ts

@@ -1,5 +1,4 @@
 import { RequiredSome, Type } from 'ts-gems';
-import * as vg from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
 import { nodeInspectCustom } from '../utils/inspect.util.js';
@@ -25,11 +24,6 @@ export declare abstract class DataType {
     readonly description?: string;
     readonly isAnonymous: boolean;
     protected constructor(document: ApiDocument, init?: DataType.InitArguments);
-    decode(v: any): any;
-    encode(v: any): any;
-    validate(v: any): any;
-    protected abstract _getDecoder(): vg.Validator<any, any>;
-    protected abstract _getEncoder(): vg.Validator<any, any>;
     exportSchema(): OpraSchema.DataType;
     extendsFrom(type: string | Type | DataType): any;
     toString(): string;

package/types/document/data-type/enum-type.d.ts

@@ -23,12 +23,10 @@ declare class EnumTypeClass extends DataType {
     readonly meanings: Record<string, string>;
     readonly ownValues: Record<string, string | number>;
     readonly ownMeanings: Record<string, string>;
-    protected _decoder?: vg.Validator<any, any>;
-    protected _encoder?: vg.Validator<any, any>;
+    readonly decode: vg.Validator<any, any>;
+    readonly encode: vg.Validator<any, any>;
     constructor(document: ApiDocument, init: EnumType.InitArguments);
     exportSchema(): OpraSchema.EnumType;
-    protected _getDecoder(): vg.Validator<any, any>;
-    protected _getEncoder(): vg.Validator<any, any>;
 }
 export interface EnumTypeConstructor {
     new (document: ApiDocument, init?: EnumType.InitArguments): EnumType;

package/types/document/data-type/mapped-type.d.ts

@@ -29,16 +29,12 @@ declare class MappedTypeClass extends DataType {
     readonly kind = "MappedType";
     readonly own: MappedType.OwnProperties;
     readonly type: ComplexType;
-    readonly additionalFields?: boolean | vg.Validator<any, any> | 'ignore';
+    readonly additionalFields?: boolean | vg.Validator | 'error';
     readonly fields: ResponsiveMap<ApiField>;
     readonly omit?: Field.Name[];
     readonly pick?: Field.Name[];
-    protected _decoder: vg.Validator<any, any>;
-    protected _encoder: vg.Validator<any, any>;
     constructor(document: ApiDocument, init: MappedType.InitArguments);
     exportSchema(): OpraSchema.MappedType;
-    protected _getDecoder(): vg.Validator<any, any>;
-    protected _getEncoder(): vg.Validator<any, any>;
 }
 /**
  * Type definition of MappedType prototype

package/types/document/data-type/simple-type.d.ts

@@ -26,12 +26,10 @@ export declare namespace SimpleType {
 declare class SimpleTypeClass extends DataType {
     readonly kind = "SimpleType";
     readonly base?: SimpleType;
-    protected _decoder: vg.Validator<any, any>;
-    protected _encoder: vg.Validator<any, any>;
     readonly own: SimpleType.OwnProperties;
+    readonly decode: vg.Validator<any, any>;
+    readonly encode: vg.Validator<any, any>;
     constructor(document: ApiDocument, init: SimpleType.InitArguments);
-    protected _getDecoder(): vg.Validator<any, any>;
-    protected _getEncoder(): vg.Validator<any, any>;
     exportSchema(): OpraSchema.SimpleType;
 }
 export interface SimpleTypeConstructor {

package/types/document/data-type/union-type.d.ts

@@ -26,14 +26,10 @@ declare class UnionTypeClass extends DataType {
     readonly kind = "UnionType";
     readonly own: UnionType.OwnProperties;
     readonly types: (ComplexType | UnionType | MappedType)[];
-    readonly additionalFields?: boolean;
+    readonly additionalFields?: boolean | vg.Validator | 'error';
     readonly fields: ResponsiveMap<ApiField>;
-    protected _decoder: vg.Validator<any, any>;
-    protected _encoder: vg.Validator<any, any>;
     constructor(document: ApiDocument, init: UnionType.InitArguments);
     exportSchema(): OpraSchema.UnionType;
-    protected _getDecoder(): vg.Validator<any, any>;
-    protected _getEncoder(): vg.Validator<any, any>;
 }
 /**
  * Type definition of UnionType constructor type

package/types/document/index.d.ts

@@ -13,3 +13,5 @@ export * from './resource/resource.js';
 export * from './resource/collection.js';
 export * from './resource/singleton.js';
 export * from './resource/storage.js';
+export * from './interfaces/collection-resource.interface.js';
+export * from './interfaces/singleton-resource.interface.js';

package/types/document/interfaces/collection-resource.interface.d.ts

@@ -0,0 +1,10 @@
+import { PartialOutput } from '../../types.js';
+export interface CollectionResource<T> {
+    create?(...args: any[]): Promise<PartialOutput<T>>;
+    delete?(...args: any[]): Promise<number> | undefined;
+    deleteMany?(...args: any[]): Promise<number> | undefined;
+    findMany?(...args: any[]): Promise<PartialOutput<T>[] | undefined>;
+    get?(...args: any[]): Promise<PartialOutput<T> | undefined>;
+    update?(...args: any[]): Promise<PartialOutput<T> | undefined>;
+    updateMany?(...args: any[]): Promise<number> | undefined;
+}

package/types/document/interfaces/singleton-resource.interface.d.ts

@@ -0,0 +1,7 @@
+import { PartialOutput } from '../../types.js';
+export interface SingletonResource<T> {
+    create?(...args: any[]): Promise<PartialOutput<T>>;
+    delete?(...args: any[]): Promise<number> | undefined;
+    get?(...args: any[]): Promise<PartialOutput<T> | undefined>;
+    update?(...args: any[]): Promise<PartialOutput<T> | undefined>;
+}

package/types/document/interfaces/storage-resource.interface.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+export interface StorageResource {
+    delete?(...args: any[]): Promise<number | undefined>;
+    get?(...args: any[]): Promise<Buffer | Readable | undefined>;
+    post?(...args: any[]): Promise<void>;
+}

package/types/document/resource/collection.d.ts

@@ -1,66 +1,72 @@
-import { StrictOmit } from 'ts-gems';
+import { StrictOmit, Type } from 'ts-gems';
+import * as vg from 'valgen';
 import { OpraFilter } from '../../filter/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import type { TypeThunkAsync } from '../../types.js';
 import type { ApiDocument } from '../api-document.js';
-import type { ComplexType } from '../data-type/complex-type.js';
+import { ComplexType } from '../data-type/complex-type.js';
 import { Resource } from './resource.js';
 export declare namespace Collection {
-    export interface InitArguments extends Resource.InitArguments, Pick<OpraSchema.Collection, 'primaryKey'> {
+    interface InitArguments extends Resource.InitArguments, StrictOmit<OpraSchema.Collection, 'kind' | 'type'> {
         type: ComplexType;
-        operations: Operations;
     }
-    export interface DecoratorOptions extends Resource.DecoratorOptions, Partial<Pick<OpraSchema.Collection, 'primaryKey'>> {
+    interface DecoratorOptions<T = any> extends Resource.DecoratorOptions {
+        primaryKey?: keyof T | (keyof T)[];
     }
-    export interface Metadata extends StrictOmit<OpraSchema.Collection, 'type'> {
+    interface Metadata extends StrictOmit<OpraSchema.Collection, 'type'> {
         name: string;
         type: TypeThunkAsync | string;
     }
-    interface Operation {
-        handlerName?: string;
+    namespace Create {
     }
-    export interface Operations {
-        create?: OpraSchema.Collection.CreateOperation & Operation;
-        delete?: OpraSchema.Collection.DeleteOperation & Operation;
-        get?: OpraSchema.Collection.GetOperation & Operation;
-        update?: OpraSchema.Collection.UpdateOperation & Operation;
-        deleteMany?: OpraSchema.Collection.DeleteManyOperation & Operation;
-        findMany?: OpraSchema.Collection.FindManyOperation & Operation;
-        updateMany?: OpraSchema.Collection.UpdateManyOperation & Operation;
+    namespace Delete {
     }
-    export type CreateOperationOptions = StrictOmit<OpraSchema.Collection.CreateOperation, 'handler'>;
-    export type DeleteOperationOptions = StrictOmit<OpraSchema.Collection.DeleteOperation, 'handler'>;
-    export type DeleteManyOperationOptions = StrictOmit<OpraSchema.Collection.DeleteManyOperation, 'handler'>;
-    export type FindManyOperationOptions = StrictOmit<OpraSchema.Collection.FindManyOperation, 'handler'>;
-    export type GetOperationOptions = StrictOmit<OpraSchema.Collection.GetOperation, 'handler'>;
-    export type UpdateOperationOptions = StrictOmit<OpraSchema.Collection.UpdateOperation, 'handler'>;
-    export type UpdateManyOperationOptions = StrictOmit<OpraSchema.Collection.UpdateManyOperation, 'handler'>;
-    export {};
+    namespace DeleteMany {
+    }
+    namespace FindMany {
+    }
+    namespace Get {
+    }
+    namespace Update {
+    }
+    namespace UpdateMany {
+    }
+    type CreateOperationOptions = OpraSchema.Collection.CreateOperation;
+    type DeleteOperationOptions = OpraSchema.Collection.DeleteOperation;
+    type DeleteManyOperationOptions = OpraSchema.Collection.DeleteManyOperation;
+    type FindManyOperationOptions = OpraSchema.Collection.FindManyOperation;
+    type GetOperationOptions = OpraSchema.Collection.GetOperation;
+    type UpdateOperationOptions = OpraSchema.Collection.UpdateOperation;
+    type UpdateManyOperationOptions = OpraSchema.Collection.UpdateManyOperation;
 }
 declare class CollectionClass extends Resource {
+    private _decoders;
+    private _encoders;
     readonly type: ComplexType;
     readonly kind = "Collection";
-    readonly operations: Collection.Operations;
+    readonly operations: OpraSchema.Collection.Operations;
     readonly controller?: object;
     readonly primaryKey: string[];
     constructor(document: ApiDocument, init: Collection.InitArguments);
     exportSchema(this: Collection): OpraSchema.Collection;
     parseKeyValue(this: Collection, value: any): any;
-    normalizeFieldPath(this: Collection, path: string | string[]): string | string[];
-    normalizeSortFields(this: Collection, fields: string | string[]): string | string[];
+    normalizeFieldPath(this: Collection, path: string | string[]): string[] | undefined;
+    normalizeSortFields(this: Collection, fields: string | string[]): string[] | undefined;
     normalizeFilter(filter: string | OpraFilter.Expression): OpraFilter.Expression | undefined;
+    getDecoder(operation: keyof OpraSchema.Collection.Operations): vg.Validator<any, any>;
+    getEncoder(operation: keyof OpraSchema.Collection.Operations): vg.Validator<any, any>;
 }
 export interface CollectionConstructor {
     prototype: Collection;
     new (document: ApiDocument, init: Collection.InitArguments): Collection;
-    (type: TypeThunkAsync | string, options?: Collection.DecoratorOptions): ClassDecorator;
-    Create: (options?: Collection.CreateOperationOptions) => PropertyDecorator;
-    Delete: (options?: Collection.DeleteOperationOptions) => PropertyDecorator;
-    Get: (options?: Collection.GetOperationOptions) => PropertyDecorator;
-    Update: (options?: Collection.UpdateOperationOptions) => PropertyDecorator;
-    FindMany: (options?: Collection.FindManyOperationOptions) => PropertyDecorator;
-    DeleteMany: (options?: Collection.DeleteManyOperationOptions) => PropertyDecorator;
-    UpdateMany: (options?: Collection.UpdateManyOperationOptions) => PropertyDecorator;
+    <T>(type: Type<T> | string, options?: Collection.DecoratorOptions<T>): ClassDecorator;
+    Create: (options?: Collection.CreateOperationOptions) => ((target: Object, propertyKey: 'create') => void);
+    Delete: (options?: Collection.DeleteOperationOptions) => ((target: Object, propertyKey: 'delete') => void);
+    DeleteMany: (options?: Collection.DeleteManyOperationOptions) => ((target: Object, propertyKey: 'deleteMany') => void);
+    Get: (options?: Collection.GetOperationOptions) => ((target: Object, propertyKey: 'get') => void);
+    FindMany: (options?: Collection.FindManyOperationOptions) => ((target: Object, propertyKey: 'findMany') => void);
+    Update: (options?: Collection.UpdateOperationOptions) => ((target: Object, propertyKey: 'update') => void);
+    UpdateMany: (options?: Collection.UpdateManyOperationOptions) => ((target: Object, propertyKey: 'updateMany') => void);
 }
 export interface Collection extends CollectionClass {
 }