@opra/common 0.25.4 → 0.26.0

package/esm/document/factory/create-document.js

@@ -1,77 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import { AnyType, Base64Type, BigintType, BooleanType, DateType, IntegerType, NullType, NumberType, ObjectIdType, ObjectType, StringType, TimestampType, TimeType, UuidType } from '../data-type/builtin/index.js';
-export async function createDocument(init, options) {
-    this.document.url = init.url;
-    if (init.info)
-        Object.assign(this.document.info, init.info);
-    if (!options?.noBuiltinTypes) {
-        const builtinDocument = await this.createBuiltinTypeDocument();
-        this.document.references.set('Opra', builtinDocument);
-        for (const [c, s] of Object.getPrototypeOf(this).constructor.designTypeMap.entries())
-            this.document._designTypeMap.set(c, s);
-    }
-    if (init.references)
-        await this.addReferences(init.references);
-    if (init.types) {
-        this.curPath.push('types');
-        if (Array.isArray(init.types)) {
-            for (const type of init.types)
-                await this.importTypeClass(type);
-        }
-        else
-            this.typeQueue.setAll(init.types);
-        await this.processTypes();
-        this.curPath.pop();
-    }
-    if (init.resources) {
-        this.curPath.push('resources');
-        if (Array.isArray(init.resources)) {
-            for (const res of init.resources)
-                await this.importSourceClass(res);
-        }
-        else
-            this.sourceQueue.setAll(init.resources);
-        await this.processSourceQueue();
-        this.curPath.pop();
-    }
-    this.document.types.sort();
-    this.document.resources.sort();
-    return this.document;
-}
-/**
- *
- * @param url
- * @protected
- */
-export async function createDocumentFromUrl(url) {
-    const resp = await fetch(url, { method: 'GET' });
-    const init = await resp.json();
-    if (!init)
-        throw new TypeError(`Invalid response returned from url: ${url}`);
-    return await this.createDocument({ ...init, url });
-}
-export async function createBuiltinTypeDocument() {
-    const init = {
-        version: OpraSchema.SpecVersion,
-        info: {
-            version: OpraSchema.SpecVersion,
-            title: 'Opra built-in types',
-            contact: [{
-                    url: 'https://github.com/oprajs/opra'
-                }
-            ],
-            license: {
-                url: 'https://github.com/oprajs/opra/blob/main/LICENSE',
-                name: 'MIT'
-            }
-        },
-        types: [AnyType, Base64Type, BigintType, BooleanType,
-            DateType, UuidType, IntegerType, NullType,
-            NumberType, ObjectType, ObjectIdType, StringType,
-            TimeType, TimestampType
-        ]
-    };
-    const factoryClass = Object.getPrototypeOf(this).constructor;
-    const factory = new factoryClass();
-    return await factory.createDocument(init, { noBuiltinTypes: true });
-}

package/esm/document/factory/factory.js

@@ -1,62 +0,0 @@
-var _a;
-import { ResponsiveMap } from '../../helpers/index.js';
-import { ApiDocument } from '../api-document.js';
-import { addReferences } from './add-references.js';
-import { createBuiltinTypeDocument, createDocument, createDocumentFromUrl } from './create-document.js';
-import { extractCollectionSchema, extractSingletonSchema, importResourceClass } from './import-resource-class.js';
-import { extractComplexTypeSchema, extractEnumTypeSchema, extractFieldSchema, extractMappedTypeSchema, extractSimpleTypeSchema, extractUnionTypeSchema, importTypeClass } from './import-type-class.js';
-import { createCollectionResource, createSingletonResource, createStorageResource, processSourceQueue } from './process-resources.js';
-import { addDataType, createDataTypeInstance, processTypes } from './process-types.js';
-/**
- * @class DocumentFactory
- */
-export class DocumentFactory {
-    constructor() {
-        this.document = new ApiDocument();
-        this.typeQueue = new ResponsiveMap();
-        this.sourceQueue = new ResponsiveMap();
-        this.circularRefs = new ResponsiveMap();
-        this.curPath = [];
-        this.cache = new Map();
-    }
-    /**
-     * Creates ApiDocument instance from given schema object
-     * @param init
-     */
-    static async createDocument(init) {
-        const factory = new DocumentFactory();
-        return factory.createDocument(init);
-    }
-    /**
-     * Downloads schema from the given URL and creates the document instance   * @param url
-     */
-    static async createDocumentFromUrl(url) {
-        const factory = new DocumentFactory();
-        return factory.createDocumentFromUrl(url);
-    }
-}
-_a = DocumentFactory;
-DocumentFactory.designTypeMap = new Map();
-(() => {
-    _a.prototype.createDocument = createDocument;
-    _a.prototype.createDocumentFromUrl = createDocumentFromUrl;
-    _a.prototype.createBuiltinTypeDocument = createBuiltinTypeDocument;
-    _a.prototype.addReferences = addReferences;
-    _a.prototype.importTypeClass = importTypeClass;
-    _a.prototype.extractSimpleTypeSchema = extractSimpleTypeSchema;
-    _a.prototype.extractComplexTypeSchema = extractComplexTypeSchema;
-    _a.prototype.extractMappedTypeSchema = extractMappedTypeSchema;
-    _a.prototype.extractUnionTypeSchema = extractUnionTypeSchema;
-    _a.prototype.extractEnumTypeSchema = extractEnumTypeSchema;
-    _a.prototype.extractFieldSchema = extractFieldSchema;
-    _a.prototype.processTypes = processTypes;
-    _a.prototype.createDataTypeInstance = createDataTypeInstance;
-    _a.prototype.addDataType = addDataType;
-    _a.prototype.importSourceClass = importResourceClass;
-    _a.prototype.extractSingletonSchema = extractSingletonSchema;
-    _a.prototype.extractCollectionSchema = extractCollectionSchema;
-    _a.prototype.processSourceQueue = processSourceQueue;
-    _a.prototype.createCollectionSource = createCollectionResource;
-    _a.prototype.createSingletonSource = createSingletonResource;
-    _a.prototype.createFileSource = createStorageResource;
-})();

package/esm/document/factory/import-resource-class.js

@@ -1,48 +0,0 @@
-import 'reflect-metadata';
-import { cloneObject, resolveClass, resolveThunk } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { RESOURCE_METADATA } from '../constants.js';
-export async function importResourceClass(thunk) {
-    const { document, sourceQueue, cache } = this;
-    const controller = await resolveThunk(thunk);
-    const cached = cache.get(controller);
-    if (cached)
-        return cached;
-    const ctor = typeof thunk === 'function' ? thunk : Object.getPrototypeOf(thunk).constructor;
-    let metadata = Reflect.getMetadata(RESOURCE_METADATA, ctor);
-    if (!metadata && OpraSchema.isSource(metadata))
-        throw new TypeError(`Class "${ctor.name}" doesn't have a valid Resource metadata`);
-    // const controller = typeof thunk === 'function' ? new ctor() : thunk;
-    // Clone metadata to prevent changing its contents
-    metadata = cloneObject(metadata);
-    const schema = cloneObject(metadata);
-    schema.controller = controller;
-    cache.set(thunk, schema);
-    if (OpraSchema.isSingleton(schema) || OpraSchema.isCollection(schema)) {
-        if (!document.getDataType(metadata.type, true) && (typeof metadata.type === 'function')) {
-            await this.importTypeClass(metadata.type);
-            await this.processTypes();
-            const dataTypeCtor = await resolveClass(metadata.type);
-            const dataType = document.getComplexType(dataTypeCtor);
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            schema.type = dataType.name;
-        }
-        // Check if data type exists
-        document.getComplexType(schema.type);
-    }
-    if (OpraSchema.isSingleton(schema))
-        await this.extractSingletonSchema(schema, ctor, metadata, controller);
-    if (OpraSchema.isCollection(schema))
-        await this.extractCollectionSchema(schema, ctor, metadata, controller);
-    sourceQueue.set(metadata.name, schema);
-}
-export async function extractSingletonSchema(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-target, ctor, metadata, controller) {
-    // Do nothing. This method is used by external modules for extending the factory
-}
-export async function extractCollectionSchema(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-target, ctor, metadata, controller) {
-    // Do nothing. This method is used by external modules for extending the factory
-}

package/esm/document/factory/import-type-class.js

@@ -1,136 +0,0 @@
-import { validator } from 'valgen';
-import { cloneObject, isConstructor, resolveThunk } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { DATATYPE_METADATA } from '../constants.js';
-export async function importTypeClass(typeThunk) {
-    const { document, typeQueue, cache } = this;
-    const thunk = await resolveThunk(typeThunk);
-    const cached = cache.get(thunk);
-    if (cached)
-        return cached;
-    const dt = document.getDataType(thunk, true);
-    if (dt && dt.name)
-        return dt.name;
-    const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk);
-    if (!(metadata && OpraSchema.isDataType(metadata))) {
-        // If thunk is a Type class
-        if (isConstructor(thunk))
-            throw new TypeError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
-        // If thunk is an Enum object
-        throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(thunk).substring(0, 20)}...`);
-    }
-    // Clone metadata to prevent changing its contents
-    const name = metadata.name;
-    const schema = cloneObject(metadata);
-    const result = name || schema;
-    if (name) {
-        if (this.document.types.has(name) || typeQueue.has(name))
-            throw new TypeError(`Type "${name}" already imported`);
-        cache.set(thunk, result);
-        typeQueue.set(name, schema);
-    }
-    // If thunk is a DataType class
-    if (isConstructor(thunk)) {
-        const ctor = thunk;
-        if (OpraSchema.isSimpleType(schema))
-            await this.extractSimpleTypeSchema(schema, ctor, metadata);
-        else if (OpraSchema.isComplexType(schema))
-            await this.extractComplexTypeSchema(schema, ctor, metadata);
-        else if (OpraSchema.isMappedType(schema))
-            await this.extractMappedTypeSchema(schema, ctor, metadata);
-        else if (OpraSchema.isUnionType(schema))
-            await this.extractUnionTypeSchema(schema, ctor, metadata);
-        else
-            throw new TypeError(`Class "${ctor.name}" doesn't have a valid DataType metadata`);
-        return result;
-    }
-    // If thunk is a EnumType object
-    const enumObject = thunk;
-    if (OpraSchema.isEnumType(schema)) {
-        let baseType;
-        if (metadata.base && Reflect.hasMetadata(DATATYPE_METADATA, metadata.base)) {
-            baseType = await this.importTypeClass(metadata.base);
-        }
-        schema.base = baseType;
-        await this.extractEnumTypeSchema(schema, enumObject, metadata);
-        return result;
-    }
-    throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(enumObject).substring(0, 20)}...`);
-}
-// noinspection JSUnusedLocalSymbols
-export async function extractSimpleTypeSchema(target, ctor, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-metadata) {
-    const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-    if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
-        target.base = await this.importTypeClass(baseClass);
-    if (typeof ctor.prototype.decode === 'function')
-        target.decoder = validator(metadata.name, ctor.prototype.decode);
-    if (typeof ctor.prototype.encode === 'function')
-        target.encoder = validator(metadata.name, ctor.prototype.encode);
-}
-export async function extractComplexTypeSchema(target, ctor, metadata) {
-    const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-    if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
-        target.base = await this.importTypeClass(baseClass);
-    target.ctor = target.ctor || ctor;
-    // Fields
-    if (metadata.fields) {
-        const fields = target.fields = {};
-        for (const [elemName, elemMeta] of Object.entries(metadata.fields)) {
-            try {
-                const t = await elemMeta.type;
-                const type = typeof t === 'function'
-                    ? await this.importTypeClass(t)
-                    : (t || '');
-                const elemSchema = fields[elemName] = {
-                    ...elemMeta,
-                    type
-                };
-                if (elemMeta.enum)
-                    elemSchema.type = await this.importTypeClass(elemMeta.enum);
-                if (!elemSchema.type && elemMeta.designType) {
-                    const mappingType = this.document.getDataType(elemMeta.designType, true);
-                    if (mappingType)
-                        elemSchema.type = mappingType.name;
-                    else
-                        elemSchema.type = await this.importTypeClass(elemMeta.designType);
-                }
-                await this.extractFieldSchema(elemSchema, ctor, elemMeta, elemName);
-                // Check enum again. External packages may modify enum value
-                if (elemMeta.enum)
-                    elemSchema.type = await this.importTypeClass(elemMeta.enum);
-                if (typeof elemSchema.type === 'function')
-                    elemSchema.type = await this.importTypeClass(elemSchema.type);
-                if (elemSchema.isArray && !elemSchema.type)
-                    throw new TypeError(`"type" must be defined explicitly for array properties`);
-                elemSchema.type = elemSchema.type || 'any';
-            }
-            catch (e) {
-                e.message = `Error in class "${ctor.name}.${elemName}". ` + e.message;
-                throw e;
-            }
-        }
-    }
-}
-export async function extractMappedTypeSchema(target, ctor, metadata) {
-    target.type = await this.importTypeClass(metadata.type);
-}
-export async function extractUnionTypeSchema(target, ctor, metadata) {
-    const oldTypes = metadata.types;
-    target.types = [];
-    for (const type of oldTypes)
-        target.types.push(await this.importTypeClass(type));
-}
-// noinspection JSUnusedLocalSymbols
-export async function extractEnumTypeSchema(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-target, enumObject, metadata) {
-    // Do nothing. This method is used by external modules for extending the factory
-}
-// noinspection JSUnusedLocalSymbols
-export async function extractFieldSchema(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-target, ctor, metadata, name) {
-    // Do nothing. This method is used by external modules for extending the factory
-}

package/esm/document/factory/index.js

@@ -1 +0,0 @@
-export * from './factory.js';

package/esm/document/factory/process-resources.js

@@ -1,63 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import { Collection } from '../resource/collection.js';
-import { Singleton } from '../resource/singleton.js';
-import { Storage } from '../resource/storage.js';
-export async function processSourceQueue() {
-    const { document, sourceQueue } = this;
-    const sourceNames = Array.from(sourceQueue.keys());
-    for (const name of sourceNames) {
-        const schema = sourceQueue.get(name);
-        if (!schema)
-            continue;
-        try {
-            if (OpraSchema.isCollection(schema)) {
-                const resource = await this.createCollectionSource(name, schema);
-                document.resources.set(name, resource);
-                continue;
-            }
-            if (OpraSchema.isSingleton(schema)) {
-                const resource = await this.createSingletonSource(name, schema);
-                document.resources.set(name, resource);
-                continue;
-            }
-            if (OpraSchema.isStorage(schema)) {
-                const resource = await this.createFileSource(name, schema);
-                document.resources.set(name, resource);
-                continue;
-            }
-        }
-        catch (e) {
-            e.message = `Error in Resource schema (${name}): ` + e.message;
-            throw e;
-        }
-        throw new TypeError(`Invalid Resource schema: ${JSON.stringify(schema).substring(0, 20)}...`);
-    }
-}
-export async function createCollectionResource(name, schema) {
-    const { document } = this;
-    const dataType = document.getComplexType(schema.type);
-    const initArgs = {
-        ...schema,
-        name,
-        type: dataType
-    };
-    return new Collection(document, initArgs);
-}
-export async function createSingletonResource(name, schema) {
-    const { document } = this;
-    const dataType = document.getComplexType(schema.type);
-    const initArgs = {
-        ...schema,
-        name,
-        type: dataType
-    };
-    return new Singleton(document, initArgs);
-}
-export async function createStorageResource(name, schema) {
-    const { document } = this;
-    const initArgs = {
-        ...schema,
-        name
-    };
-    return new Storage(document, initArgs);
-}

package/esm/document/factory/process-types.js

@@ -1,185 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import { EnumType } from '../data-type/enum-type.js';
-import { MappedType } from '../data-type/mapped-type.js';
-import { SimpleType } from '../data-type/simple-type.js';
-import { UnionType } from '../data-type/union-type.js';
-export async function processTypes() {
-    const { document, typeQueue } = this;
-    // Create DataType instances
-    for (const [name, schema] of typeQueue.entries()) {
-        const dataType = this.createDataTypeInstance(schema.kind, name);
-        document.types.set(name, dataType);
-    }
-    // Process schemas
-    const typeNames = Array.from(typeQueue.keys());
-    for (const name of typeNames) {
-        if (!typeQueue.has(name))
-            continue;
-        this.addDataType(name);
-    }
-    document.invalidate();
-}
-export function createDataTypeInstance(kind, name) {
-    const dataType = {
-        document: this.document,
-        kind,
-        name
-    };
-    switch (kind) {
-        case OpraSchema.ComplexType.Kind:
-            Object.setPrototypeOf(dataType, ComplexType.prototype);
-            break;
-        case OpraSchema.EnumType.Kind:
-            Object.setPrototypeOf(dataType, EnumType.prototype);
-            break;
-        case OpraSchema.MappedType.Kind:
-            Object.setPrototypeOf(dataType, MappedType.prototype);
-            break;
-        case OpraSchema.SimpleType.Kind:
-            Object.setPrototypeOf(dataType, SimpleType.prototype);
-            break;
-        case OpraSchema.UnionType.Kind:
-            Object.setPrototypeOf(dataType, UnionType.prototype);
-            break;
-        default:
-            throw new TypeError(`Unknown DataType kind (${kind})`);
-    }
-    return dataType;
-}
-export function addDataType(schemaOrName) {
-    const { document, typeQueue, circularRefs, curPath } = this;
-    const name = typeof schemaOrName === 'string' ? schemaOrName : undefined;
-    let schema;
-    let dataType;
-    if (name) {
-        // Check if data type exists in document
-        dataType = document.getDataType(name);
-        // Get schema from stack, it is already done if not exist
-        schema = typeQueue.get(name);
-        if (!schema)
-            return dataType;
-        // Detect circular refs
-        if (circularRefs.has(name))
-            throw new TypeError(`Circular reference detected. ${[...Array.from(circularRefs.keys()), name].join('>')}`);
-        circularRefs.set(name, 1);
-    }
-    else
-        schema = schemaOrName;
-    try {
-        // Init base
-        let base;
-        if ((OpraSchema.isSimpleType(schema) || OpraSchema.isComplexType(schema) || OpraSchema.isEnumType(schema)) && schema.base) {
-            curPath.push(typeof schema.base === 'string' ? schema.base : '[base]');
-            base = this.addDataType(schema.base);
-            curPath.pop();
-        }
-        // **** Init SimpleType ****
-        if (OpraSchema.isSimpleType(schema)) {
-            const initArgs = {
-                ...schema,
-                name,
-                base
-            };
-            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-            if (name)
-                curPath.push(name);
-            SimpleType.apply(dataType, [document, initArgs]);
-            if (name)
-                curPath.pop();
-            return dataType;
-        }
-        // **** Init ComplexType ****
-        if (OpraSchema.isComplexType(schema)) {
-            const initArgs = {
-                ...schema,
-                name,
-                base
-            };
-            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-            if (name)
-                curPath.push(name);
-            ComplexType.apply(dataType, [document, initArgs]);
-            if (name)
-                typeQueue.delete(name);
-            // process fields
-            if (schema.fields) {
-                for (const [elemName, v] of Object.entries(schema.fields)) {
-                    const elemSchema = typeof v === 'object' ? v : { type: v };
-                    curPath.push(`${name}.${elemName}[type]`);
-                    const elemType = this.addDataType(elemSchema.type);
-                    dataType.addField({
-                        ...elemSchema,
-                        name: elemName,
-                        type: elemType
-                    });
-                    curPath.pop();
-                }
-            }
-            if (name)
-                curPath.pop();
-            return dataType;
-        }
-        // **** Init EnumType ****
-        if (OpraSchema.isEnumType(schema)) {
-            const initArgs = {
-                ...schema,
-                name,
-                base
-            };
-            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-            if (name)
-                curPath.push(name);
-            EnumType.apply(dataType, [document, initArgs]);
-            if (name)
-                curPath.pop();
-            return dataType;
-        }
-        // **** Init UnionType ****
-        if (OpraSchema.isUnionType(schema)) {
-            const unionTypes = schema.types.map(t => this.addDataType(t));
-            const initArgs = {
-                ...schema,
-                name,
-                types: unionTypes
-            };
-            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-            if (name)
-                curPath.push(name);
-            UnionType.apply(dataType, [document, initArgs]);
-            if (name)
-                curPath.pop();
-            return dataType;
-        }
-        // **** Init MappedType ****
-        if (OpraSchema.isMappedType(schema)) {
-            const dt = this.addDataType(schema.type);
-            if (!(dt instanceof ComplexType))
-                throw new TypeError(`MappedType requires a ComplexType`);
-            const initArgs = {
-                ...schema,
-                name,
-                type: dt
-            };
-            dataType = dataType || this.createDataTypeInstance(schema.kind, name);
-            if (name)
-                curPath.push(name);
-            MappedType.apply(dataType, [document, initArgs]);
-            if (name)
-                curPath.pop();
-            return dataType;
-        }
-    }
-    catch (e) {
-        if (curPath.length)
-            e.message = `Error at ${curPath.join('/')}: ` + e.message;
-        throw e;
-    }
-    finally {
-        if (name) {
-            circularRefs.delete(name);
-            typeQueue.delete(name);
-        }
-    }
-    throw new TypeError(`Invalid DataType schema: ${JSON.stringify(schema).substring(0, 20)}...`);
-}

package/esm/document/utils/generate-codec.js

@@ -1,33 +0,0 @@
-import * as vg from 'valgen';
-import { ComplexType } from '../data-type/complex-type.js';
-import { EnumType } from '../data-type/enum-type.js';
-import { MappedType } from '../data-type/mapped-type.js';
-import { SimpleType } from '../data-type/simple-type.js';
-import { UnionType } from '../data-type/union-type.js';
-export function generateCodec(type, codec, options) {
-    return _generateCodec(type, codec, options);
-}
-export function _generateCodec(type, codec, options) {
-    const schema = {};
-    for (const f of type.fields.values()) {
-        let fn;
-        if (f.type instanceof SimpleType || f.type instanceof EnumType) {
-            fn = f.type[codec];
-        }
-        else if (f.type instanceof ComplexType || f.type instanceof MappedType || f.type instanceof UnionType) {
-            fn = _generateCodec(f.type, codec, options);
-        }
-        /* istanbul ignore next */
-        if (!fn)
-            throw new TypeError(`Can't generate codec for (${f.type})`);
-        if (f.isArray)
-            fn = vg.isArray(fn);
-        schema[f.name] = !options.partial && f.required ? vg.required(fn) : vg.optional(fn);
-    }
-    return vg.isObject(schema, {
-        ctor: type.ctor,
-        additionalFields: type.additionalFields ?? false,
-        name: type.name,
-        caseInSensitive: true,
-    });
-}

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

@@ -1,30 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import type { Collection } from '../resource/collection';
-import { Resource } from '../resource/resource.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 declare namespace CollectionDecorator {
-    var Create: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
-    var Delete: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
-    var DeleteMany: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
-    var Get: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
-    var FindMany: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
-    var Update: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
-    var UpdateMany: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
-    var Action: (options: any) => PropertyDecorator;
-}
-export interface CollectionDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
-    <T>(type: Type<T> | string, options?: Collection.DecoratorOptions<T>): ClassDecorator;
-    Action: (options?: Resource.ActionOptions) => (<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);
-    Create: (options?: Collection.CreateEndpointOptions) => ((target: Object, propertyKey: 'create') => void);
-    Delete: (options?: Collection.DeleteEndpointOptions) => ((target: Object, propertyKey: 'delete') => void);
-    DeleteMany: (options?: Collection.DeleteManyEndpointOptions) => ((target: Object, propertyKey: 'deleteMany') => void);
-    Get: (options?: Collection.GetEndpointOptions) => ((target: Object, propertyKey: 'get') => void);
-    FindMany: (options?: Collection.FindManyEndpointOptions) => ((target: Object, propertyKey: 'findMany') => void);
-    Update: (options?: Collection.UpdateEndpointOptions) => ((target: Object, propertyKey: 'update') => void);
-    UpdateMany: (options?: Collection.UpdateManyEndpointOptions) => ((target: Object, propertyKey: 'updateMany') => void);
-}
-export {};

package/types/document/decorators/resource.decorator.d.ts

@@ -1,9 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import type { Resource } from '../resource/resource';
-export interface ResourceDecorator {
-    Action: (options?: Resource.ActionOptions) => PropertyDecorator;
-}
-export declare function ResourceDecorator<O extends Resource.DecoratorOptions>(kind: OpraSchema.Resource.Kind, options?: O): ClassDecorator;
-export declare namespace ResourceDecorator {
-    var Action: (options: any) => PropertyDecorator;
-}