@opra/common 0.33.13 → 1.0.0-alpha.1

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

@@ -1,36 +0,0 @@
-import { RequiredSome, Type } from 'ts-gems';
-import { IsObject } from 'valgen';
-import { ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import type { ComplexType } from './complex-type.js';
-import { DataType } from './data-type.js';
-import { ApiField } from './field.js';
-import type { MappedType } from './mapped-type.js';
-import type { MixinType } from './mixin-type.js';
-/**
- * @class ComplexType
- */
-export declare class ComplexTypeClass extends DataType {
-    readonly kind: OpraSchema.DataType.Kind;
-    readonly ctor: Type;
-    readonly base?: ComplexType | MixinType | MappedType;
-    readonly own: ComplexType.OwnProperties;
-    readonly fields: ResponsiveMap<ApiField>;
-    readonly abstract?: boolean;
-    readonly additionalFields?: boolean | DataType | 'error';
-    constructor(document: ApiDocument, init: ComplexType.InitArguments);
-    findField(nameOrPath: string): ApiField | undefined;
-    getField(nameOrPath: string): ApiField;
-    iteratePath(path: string, silent?: boolean): IterableIterator<[string, ApiField | undefined, string]>;
-    normalizeFieldNames(fieldNames: string | string[], allowSortSigns?: boolean): string[] | undefined;
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): any;
-    isTypeOf(t: Type | Function): boolean;
-    extendsFrom(t: string | Type | DataType): boolean;
-    generateCodec<T extends Object = any>(codec: 'decode' | 'encode', options?: DataType.GenerateCodecOptions): IsObject.Validator<T>;
-    generateCodecSchema(codec: 'decode' | 'encode', options?: DataType.GenerateCodecOptions): IsObject.Schema;
-    protected _generateCodecSchema(codec: 'decode' | 'encode', options?: RequiredSome<DataType.GenerateCodecOptions, 'pick' | 'omit'>): IsObject.Schema;
-    protected _buildOverwriteFieldsTree(obj: Record<string, DataType.OverrideFieldsConfig>): Record<string, DataType.OverrideFieldsConfig>;
-}

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

@@ -1,2 +0,0 @@
-import type { ComplexType } from './complex-type.js';
-export declare function ComplexTypeDecorator(options?: ComplexType.DecoratorOptions): (target: Function) => void;

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

@@ -1,18 +0,0 @@
-import { Validator } from 'valgen';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { DataType } from './data-type.js';
-import type { EnumType } from './enum-type.js';
-export declare class EnumTypeClass extends DataType {
-    readonly enumObject?: object;
-    readonly kind = "EnumType";
-    readonly base?: EnumType;
-    readonly values: Record<OpraSchema.EnumType.Value, OpraSchema.EnumType.ValueInfo>;
-    readonly ownValues: Record<OpraSchema.EnumType.Value, OpraSchema.EnumType.ValueInfo>;
-    readonly decode: Validator;
-    readonly encode: Validator;
-    constructor(document: ApiDocument, init: EnumType.InitArguments);
-    isTypeOf(t: object): boolean;
-    exportSchema(): OpraSchema.EnumType;
-    generateCodec(codec: 'decode' | 'encode'): Validator;
-}

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

@@ -1,31 +0,0 @@
-import { Type } from 'ts-gems';
-import { Validator } from 'valgen';
-import type { OpraSchema } from '../../schema/index.js';
-import type { ComplexType } from './complex-type.js';
-import type { DataType } from './data-type.js';
-import type { ApiField } from './field.js';
-export declare class FieldClass {
-    readonly owner: ComplexType;
-    readonly origin?: ComplexType;
-    readonly type: DataType;
-    readonly name: string;
-    readonly designType?: Type;
-    description?: string;
-    isArray?: boolean;
-    default?: any;
-    fixed?: string | number | boolean;
-    required?: boolean;
-    readonly?: boolean;
-    writeonly?: boolean;
-    exclusive?: boolean;
-    translatable?: boolean;
-    deprecated?: boolean | string;
-    examples?: any[] | Record<string, any>;
-    pattern?: RegExp;
-    partialUpdate?: boolean;
-    constructor(owner: ComplexType, init: ApiField.InitArguments);
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Field;
-    generateCodec(codec: 'decode' | 'encode', options?: DataType.GenerateCodecOptions): Validator;
-}

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

@@ -1,5 +0,0 @@
-import type { ApiField } from './field';
-export interface FieldDecorator {
-    (options?: ApiField.DecoratorOptions): PropertyDecorator;
-}
-export declare function FieldDecorator(options?: ApiField.DecoratorOptions): PropertyDecorator;

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

@@ -1,46 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import { TypeThunkAsync } from '../../types.js';
-import type { ComplexType } from './complex-type.js';
-import type { DataType } from './data-type.js';
-import type { EnumType } from './enum-type.js';
-import { FieldClass } from './field-class.js';
-import { FieldDecorator } from './field-decorator.js';
-/**
- * Type definition of ComplexType constructor type
- * @type FieldConstructor
- */
-export interface FieldConstructor extends FieldDecorator {
-    prototype: FieldClass;
-    new (owner: ComplexType, init: ApiField.InitArguments): FieldClass;
-}
-export interface ApiField extends FieldClass {
-}
-/**
- * @class ApiField
- * @decorator ApiField
- */
-export declare const ApiField: FieldConstructor;
-/**
- * @namespace ApiField
- */
-export declare namespace ApiField {
-    interface InitArguments extends StrictOmit<OpraSchema.Field, 'type' | 'pattern'> {
-        name: string;
-        type: DataType;
-        designType?: Type;
-        origin?: ComplexType;
-        pattern?: string | RegExp;
-    }
-    interface DecoratorOptions extends Partial<StrictOmit<OpraSchema.Field, 'isArray' | 'type' | 'pattern'>> {
-        type?: string | OpraSchema.DataType | TypeThunkAsync;
-        enum?: EnumType.EnumObject | EnumType.EnumArray;
-        pattern?: string | RegExp;
-    }
-    interface Metadata extends StrictOmit<OpraSchema.Field, 'type' | 'pattern'> {
-        type?: string | OpraSchema.DataType | TypeThunkAsync;
-        enum?: EnumType.EnumObject | EnumType.EnumArray;
-        designType?: Type;
-        pattern?: string | RegExp;
-    }
-}

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

@@ -1,18 +0,0 @@
-import type { Field } from '../../schema/data-type/field.interface.js';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import type { ComplexType } from './complex-type.js';
-import { ComplexTypeClass } from './complex-type-class.js';
-import type { MappedType } from './mapped-type.js';
-import type { MixinType } from './mixin-type';
-export declare class MappedTypeClass extends ComplexTypeClass {
-    readonly kind: OpraSchema.DataType.Kind;
-    readonly own: MappedType.OwnProperties;
-    readonly base: ComplexType | MixinType | MappedType;
-    readonly omit?: Field.Name[];
-    readonly pick?: Field.Name[];
-    readonly partial?: Field.Name[] | boolean;
-    constructor(document: ApiDocument, init: MappedType.InitArguments);
-    exportSchema(): any;
-}
-export declare function getIsInheritedPredicateFn(pick?: Field.Name[], omit?: Field.Name[]): (propertyName: string) => boolean;

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

@@ -1,12 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexType } from './complex-type.js';
-import { MappedType } from './mapped-type.js';
-import type { MixinType } from './mixin-type';
-export declare class MixinTypeClass extends ComplexType {
-    readonly kind: OpraSchema.DataType.Kind;
-    readonly own: MixinType.OwnProperties;
-    readonly types: (ComplexType | MixinType | MappedType)[];
-    constructor(document: ApiDocument, init: MixinType.InitArguments);
-    exportSchema(): any;
-}

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

@@ -1,19 +0,0 @@
-import { Validator } from 'valgen';
-import type { ApiDocument } from '../api-document.js';
-import { DataType } from './data-type.js';
-import type { SimpleType } from './simple-type.js';
-/**
- * @class SimpleType
- */
-export declare class SimpleTypeClass extends DataType {
-    readonly kind = "SimpleType";
-    readonly base?: SimpleType;
-    readonly own: SimpleType.OwnProperties;
-    readonly decode: Validator;
-    readonly encode: Validator;
-    constructor(document: ApiDocument, init: SimpleType.InitArguments);
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): any;
-    generateCodec(codec: 'decode' | 'encode'): Validator;
-}

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

@@ -1,2 +0,0 @@
-import type { SimpleType } from './simple-type.js';
-export declare function SimpleTypeDecorator(options?: SimpleType.DecoratorOptions): (target: Function) => void;

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

@@ -1,10 +0,0 @@
-import { OpraSchema } from '../schema/index.js';
-export declare class DocumentBase {
-    url?: string;
-    info: OpraSchema.DocumentInfo;
-    constructor();
-    /**
-     * Export as OPRA schema definition object
-     */
-    exportSchema(): OpraSchema.DocumentBase;
-}

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

@@ -1,49 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { ThunkAsync } from '../../types.js';
-import { ApiDocument } from '../api-document.js';
-import { Collection } from '../resource/collection.js';
-import { Container } from '../resource/container.js';
-import { Resource } from '../resource/resource.js';
-import { Singleton } from '../resource/singleton.js';
-import { Storage } from '../resource/storage.js';
-import { TypeDocumentFactory } from './type-document-factory.js';
-export declare namespace ApiDocumentFactory {
-    interface RootInit extends StrictOmit<OpraSchema.Container, 'kind' | 'resources'> {
-        resources?: ThunkAsync<Type | object>[] | Record<OpraSchema.Resource.Name, OpraSchema.Resource>;
-    }
-    interface InitArguments extends TypeDocumentFactory.InitArguments {
-        root?: RootInit;
-    }
-    type ResourceInitializer = (Collection.InitArguments & {
-        kind: OpraSchema.Collection.Kind;
-    }) | (Singleton.InitArguments & {
-        kind: OpraSchema.Singleton.Kind;
-    }) | (Storage.InitArguments & {
-        kind: OpraSchema.Storage.Kind;
-    }) | (StrictOmit<Container.InitArguments, 'resources'> & {
-        kind: OpraSchema.Container.Kind;
-        resources?: ResourceInitializer[];
-    });
-}
-/**
- * @class ApiDocumentFactory
- */
-export declare class ApiDocumentFactory extends TypeDocumentFactory {
-    protected document: ApiDocument;
-    protected resourceQueue: ResponsiveMap<any>;
-    /**
-     * Creates ApiDocument instance from given schema object
-     * @param init
-     */
-    static createDocument(init: ApiDocumentFactory.InitArguments): Promise<ApiDocument>;
-    /**
-     * Downloads schema from the given URL and creates the document instance   * @param url
-     */
-    static createDocumentFromUrl(url: string): Promise<ApiDocument>;
-    protected initDocument(init: ApiDocumentFactory.InitArguments): Promise<ApiDocument>;
-    protected importResourceSchema(name: string, schema: OpraSchema.Resource): Promise<ApiDocumentFactory.ResourceInitializer>;
-    protected importResourceInstance(thunk: ThunkAsync<Type | object>): Promise<ApiDocumentFactory.ResourceInitializer>;
-    protected createResource(container: Container, initArguments: ApiDocumentFactory.ResourceInitializer): Promise<Resource>;
-}

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

@@ -1,57 +0,0 @@
-import { PartialSome, StrictOmit, Type } from 'ts-gems';
-import { ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { ThunkAsync } from '../../types.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import { DataType } from '../data-type/data-type.js';
-import { EnumType } from '../data-type/enum-type.js';
-import { MappedType } from '../data-type/mapped-type.js';
-import { MixinType } from '../data-type/mixin-type.js';
-import { SimpleType } from '../data-type/simple-type.js';
-import { TypeDocument } from '../type-document.js';
-type ReferenceUnion = string | OpraSchema.TypeDocument | TypeDocument;
-export declare namespace TypeDocumentFactory {
-    interface InitArguments extends PartialSome<StrictOmit<OpraSchema.TypeDocument, 'references' | 'types'>, 'version'> {
-        references?: Record<string, ReferenceUnion | Promise<ReferenceUnion>>;
-        types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[] | Record<string, OpraSchema.DataType>;
-        noBuiltinTypes?: boolean;
-    }
-    type DataTypeInitializer = (ComplexType.InitArguments & {
-        kind: OpraSchema.ComplexType.Kind;
-    }) | (SimpleType.InitArguments & {
-        kind: OpraSchema.SimpleType.Kind;
-    }) | (MixinType.InitArguments & {
-        kind: OpraSchema.MixinType.Kind;
-    }) | (MappedType.InitArguments & {
-        kind: OpraSchema.MappedType.Kind;
-    }) | (EnumType.InitArguments & {
-        kind: OpraSchema.EnumType.Kind;
-    });
-}
-/**
- * @class TypeDocumentFactory
- */
-export declare class TypeDocumentFactory {
-    static designTypeMap: Map<Function | Type<any>, string>;
-    protected document: TypeDocument;
-    protected typeQueue: ResponsiveMap<any>;
-    protected circularRefs: Map<any, any>;
-    protected curPath: string[];
-    protected cache: Map<any, any>;
-    /**
-     * Creates ApiDocument instance from given schema object
-     */
-    static createDocument(init: TypeDocumentFactory.InitArguments): Promise<TypeDocument>;
-    /**
-     * Downloads schema from the given URL and creates the document instance   * @param url
-     */
-    static createDocumentFromUrl(url: string): Promise<TypeDocument>;
-    protected initDocument(init: TypeDocumentFactory.InitArguments): Promise<TypeDocument>;
-    initDocumentFromUrl(url: string): Promise<TypeDocument>;
-    protected createBuiltinTypeDocument(): Promise<TypeDocument>;
-    protected addReferences(references: Record<string, ReferenceUnion | Promise<ReferenceUnion>>): Promise<void>;
-    protected importDataType(thunk: ThunkAsync<string | Type | EnumType.EnumObject | EnumType.EnumArray | OpraSchema.DataType>): Promise<DataType>;
-    protected prepareDataTypeInitArguments(schema: TypeDocumentFactory.DataTypeInitializer | OpraSchema.DataType, ctor?: Type): Promise<TypeDocumentFactory.DataTypeInitializer | undefined>;
-    protected createDataTypeInstance(kind: OpraSchema.DataType.Kind, name?: string): DataType;
-}
-export {};

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

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

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

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

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

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

package/types/document/resource/action-decorator.d.ts

@@ -1,8 +0,0 @@
-import { Type } from 'ts-gems';
-import { TypeThunkAsync } from '../../types.js';
-import { ResourceDecorator } from './resource-decorator.js';
-export type ActionDecorator = ((target: Object, propertyKey: string) => void) & {
-    Parameter(name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type): ActionDecorator;
-    Returns(t: TypeThunkAsync | string): ActionDecorator;
-};
-export declare function createActionDecorator<T extends ActionDecorator, M extends ResourceDecorator.ActionMetadata>(options: any, bannedProperties: string[] | readonly string[], list: ((operationMeta: M) => void)[]): T;

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

@@ -1,30 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { Validator } from 'valgen';
-import { OpraSchema } from '../../schema/index.js';
-import { DataType } from '../data-type/data-type.js';
-import { Endpoint } from './endpoint.js';
-import type { Resource } from './resource';
-import type { ResourceDecorator } from './resource-decorator.js';
-/**
- *
- * @class Action
- */
-export declare class Action extends Endpoint {
-    readonly resource: Resource;
-    readonly name: string;
-    readonly kind = "action";
-    returnType?: DataType;
-    returnMime?: string;
-    encodeReturning: Validator;
-    constructor(resource: Resource, name: string, init: Action.InitArguments);
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Endpoint;
-}
-export declare namespace Action {
-    interface InitArguments extends StrictOmit<ResourceDecorator.ActionMetadata, 'parameters' | 'returnType'> {
-        parameters: Record<string, Endpoint.ParameterInit>;
-        returnType?: DataType;
-        returnMime?: string;
-    }
-}

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

@@ -1,20 +0,0 @@
-import { OpraFilter } from '../../filter/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import type { Collection } from './collection.js';
-import type { Container } from './container.js';
-import { CrudResource } from './crud-resource.js';
-export declare class CollectionClass extends CrudResource {
-    readonly kind: OpraSchema.Resource.Kind;
-    readonly type: ComplexType;
-    readonly primaryKey: string[];
-    constructor(parent: ApiDocument | Container, init: Collection.InitArguments);
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Collection;
-    parseKeyValue(value: any): any;
-    normalizeFieldNames(fields: string | string[], allowSortSigns?: boolean): string[] | undefined;
-    normalizeSortFields(fields: string | string[]): string[] | undefined;
-    normalizeFilter(filter: string | OpraFilter.Expression): OpraFilter.Expression | undefined;
-}

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

@@ -1,204 +0,0 @@
-import { Combine, StrictOmit, Type } from 'ts-gems';
-import type { OpraFilter } from '../../filter/index.js';
-import { Field } from '../../schema/data-type/field.interface.js';
-import { OpraSchema } from '../../schema/index.js';
-import { TypeThunkAsync } from '../../types.js';
-import { EnumType } from '../data-type/enum-type.js';
-import { ActionDecorator } from './action-decorator.js';
-import type { Collection } from './collection.js';
-import { ResourceDecorator } from './resource-decorator.js';
-type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
-declare const operationProperties: readonly ["create", "delete", "deleteMany", "get", "findMany", "update", "updateMany"];
-type OperationProperties = typeof operationProperties[number];
-export declare function CollectionDecorator(type: Type | string, options?: Collection.DecoratorOptions): ClassDecorator;
-export interface CollectionDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
-    <T>(type: Type<T> | string, options?: Collection.DecoratorOptions<T>): ClassDecorator;
-    Action: (options?: CollectionDecorator.Action.Options) => (<T, K extends keyof T>(target: T, propertyKey: ErrorMessage<Exclude<K, OperationProperties>, `'${string & K}' property is reserved for operation endpoints and can not be used for actions`>) => void) & ActionDecorator;
-    Create: typeof CollectionDecorator.Create;
-    Delete: typeof CollectionDecorator.Delete;
-    DeleteMany: typeof CollectionDecorator.DeleteMany;
-    Get: typeof CollectionDecorator.Get;
-    FindMany: typeof CollectionDecorator.FindMany;
-    Update: typeof CollectionDecorator.Update;
-    UpdateMany: typeof CollectionDecorator.UpdateMany;
-}
-/**
- * @namespace CollectionDecorator
- */
-export declare namespace CollectionDecorator {
-    interface Metadata extends StrictOmit<OpraSchema.Collection, 'kind' | 'type' | 'operations' | 'actions'> {
-        kind: OpraSchema.Collection.Kind;
-        name: string;
-        type: TypeThunkAsync | string;
-        actions?: Record<string, ResourceDecorator.OperationMetadata>;
-        operations?: {
-            create: Create.Metadata;
-            delete: Delete.Metadata;
-            deleteMany: DeleteMany.Metadata;
-            get: Get.Metadata;
-            findMany: FindMany.Metadata;
-            update: Update.Metadata;
-            updateMany: UpdateMany.Metadata;
-        };
-    }
-    interface FieldDecoratorOptions extends Partial<StrictOmit<OpraSchema.Field, 'type'>> {
-        type?: string | OpraSchema.DataType | TypeThunkAsync;
-        enum?: EnumType.EnumObject | EnumType.EnumArray;
-    }
-    /**
-     * @namespace Action
-     */
-    namespace Action {
-        interface Metadata extends ResourceDecorator.ActionMetadata {
-        }
-        interface Options extends ResourceDecorator.ActionOptions {
-        }
-    }
-    /**
-     * @namespace Create
-     */
-    namespace Create {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Collection.Operations.Create> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Collection.Operations.Create>> {
-        }
-    }
-    /**
-     * @namespace Delete
-     */
-    namespace Delete {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Collection.Operations.Delete> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Collection.Operations.Delete>> {
-        }
-    }
-    /**
-     * @namespace DeleteMany
-     */
-    namespace DeleteMany {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Collection.Operations.DeleteMany> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Collection.Operations.DeleteMany>> {
-        }
-    }
-    /**
-     * @namespace FindMany
-     */
-    namespace FindMany {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Collection.Operations.FindMany> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Collection.Operations.FindMany>> {
-        }
-    }
-    /**
-     * @namespace Get
-     */
-    namespace Get {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Collection.Operations.Get> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Collection.Operations.Get>> {
-        }
-    }
-    /**
-     * @namespace Update
-     */
-    namespace Update {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Collection.Operations.Update> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Collection.Operations.Update>> {
-        }
-    }
-    /**
-     * @namespace UpdateMany
-     */
-    namespace UpdateMany {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Collection.Operations.UpdateMany> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Collection.Operations.UpdateMany>> {
-        }
-    }
-}
-export declare namespace CollectionDecorator {
-    /**
-     * Action PropertyDecorator
-     */
-    function Action(options: ResourceDecorator.OperationOptions): ActionDecorator;
-    /**
-     * Create PropertyDecorator
-     */
-    type CreateDecorator = ((target: Object, propertyKey: 'create') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => CreateDecorator;
-        InputMaxContentSize: (sizeInBytes: number) => CreateDecorator;
-        InputPickFields: (...fields: Field.QualifiedName[]) => CreateDecorator;
-        InputOmitFields: (...fields: Field.QualifiedName[]) => CreateDecorator;
-        InputOverwriteFields: (fields: Record<string, FieldDecoratorOptions>) => CreateDecorator;
-        OutputPickFields: (...fields: Field.QualifiedName[]) => CreateDecorator;
-        OutputOmitFields: (...fields: Field.QualifiedName[]) => CreateDecorator;
-        OutputOverwriteFields: (fields: Record<string, FieldDecoratorOptions>) => CreateDecorator;
-    };
-    function Create(options?: Create.Options): CreateDecorator;
-    /**
-     * Delete PropertyDecorator
-     */
-    type DeleteDecorator = ((target: Object, propertyKey: 'delete') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => DeleteDecorator;
-    };
-    function Delete(options?: Delete.Options): DeleteDecorator;
-    /**
-     * DeleteMany PropertyDecorator
-     */
-    type DeleteManyDecorator = ((target: Object, propertyKey: 'deleteMany') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => DeleteManyDecorator;
-        Filter: (field: Field.QualifiedName, operators?: OpraFilter.ComparisonOperator[] | string, notes?: string) => DeleteManyDecorator;
-    };
-    function DeleteMany(options?: DeleteMany.Options): DeleteManyDecorator;
-    /**
-     * Get PropertyDecorator
-     */
-    type GetDecorator = ((target: Object, propertyKey: 'get') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => GetDecorator;
-        OutputPickFields: (...fields: Field.QualifiedName[]) => GetDecorator;
-        OutputOmitFields: (...fields: Field.QualifiedName[]) => GetDecorator;
-        OutputOverwriteFields: (fields: Record<string, FieldDecoratorOptions>) => GetDecorator;
-    };
-    function Get(options?: Get.Options): GetDecorator;
-    /**
-     * FindMany PropertyDecorator
-     */
-    type FindManyDecorator = ((target: Object, propertyKey: 'findMany') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => FindManyDecorator;
-        SortFields: (...fields: Field.QualifiedName[]) => FindManyDecorator;
-        DefaultSort: (...fields: Field.QualifiedName[]) => FindManyDecorator;
-        Filter: (field: Field.QualifiedName, operators?: OpraFilter.ComparisonOperator[] | string, notes?: string) => FindManyDecorator;
-        OutputPickFields: (...fields: Field.QualifiedName[]) => FindManyDecorator;
-        OutputOmitFields: (...fields: Field.QualifiedName[]) => FindManyDecorator;
-        OutputOverwriteFields: (fields: Record<string, FieldDecoratorOptions>) => FindManyDecorator;
-    };
-    function FindMany(options?: FindMany.Options): FindManyDecorator;
-}
-export declare namespace CollectionDecorator {
-    type UpdateDecorator = ((target: Object, propertyKey: 'update') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => UpdateDecorator;
-        InputMaxContentSize: (sizeInBytes: number) => UpdateDecorator;
-        InputPickFields: (...fields: Field.QualifiedName[]) => UpdateDecorator;
-        InputOmitFields: (...fields: Field.QualifiedName[]) => UpdateDecorator;
-        InputOverwriteFields: (fields: Record<string, FieldDecoratorOptions>) => UpdateDecorator;
-        OutputPickFields: (...fields: Field.QualifiedName[]) => UpdateDecorator;
-        OutputOmitFields: (...fields: Field.QualifiedName[]) => UpdateDecorator;
-        OutputOverwriteFields: (fields: Record<string, FieldDecoratorOptions>) => UpdateDecorator;
-    };
-    function Update(options?: Update.Options): UpdateDecorator;
-}
-export declare namespace CollectionDecorator {
-    type UpdateManyDecorator = ((target: Object, propertyKey: 'updateMany') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => UpdateManyDecorator;
-        InputMaxContentSize: (sizeInBytes: number) => UpdateManyDecorator;
-        InputPickFields: (...fields: Field.QualifiedName[]) => UpdateManyDecorator;
-        InputOmitFields: (...fields: Field.QualifiedName[]) => UpdateManyDecorator;
-        InputOverwriteFields: (fields: Record<string, FieldDecoratorOptions>) => UpdateManyDecorator;
-        Filter: (field: Field.QualifiedName, operators?: OpraFilter.ComparisonOperator[] | string, notes?: string) => UpdateManyDecorator;
-    };
-    function UpdateMany(options?: UpdateMany.Options): UpdateManyDecorator;
-    function UpdateMany(description?: string): UpdateManyDecorator;
-}
-export {};