@opra/common 0.33.12 → 1.0.0-alpha.1

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 {};

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

@@ -1,62 +0,0 @@
-import { Combine, StrictOmit } from 'ts-gems';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import { CollectionClass } from './collection-class.js';
-import { CollectionDecorator } from './collection-decorator.js';
-import type { Container } from './container.js';
-import { Resource } from './resource.js';
-export interface Collection extends CollectionClass {
-}
-export interface CollectionConstructor extends CollectionDecorator {
-    prototype: CollectionClass;
-    new (parent: ApiDocument | Container, init: Collection.InitArguments): CollectionClass;
-}
-/**
- * @class Collection
- * @decorator Collection
- */
-export declare const Collection: CollectionConstructor;
-/**
- * @namespace Collection
- */
-export declare namespace Collection {
-    interface InitArguments extends StrictOmit<Combine<Resource.InitArguments, CollectionDecorator.Metadata>, 'kind' | 'type'> {
-        name: string;
-        type: ComplexType;
-    }
-    interface DecoratorOptions<T = any> extends Partial<StrictOmit<CollectionDecorator.Metadata, 'kind' | 'operations' | 'actions' | 'primaryKey'>> {
-        primaryKey?: keyof T | (keyof T)[];
-    }
-    interface Action {
-    }
-    namespace Action {
-    }
-    interface Create {
-    }
-    namespace Create {
-    }
-    interface Delete {
-    }
-    namespace Delete {
-    }
-    interface DeleteMany {
-    }
-    namespace DeleteMany {
-    }
-    interface FindMany {
-    }
-    namespace FindMany {
-    }
-    interface Get {
-    }
-    namespace Get {
-    }
-    interface Update {
-    }
-    namespace Update {
-    }
-    interface UpdateMany {
-    }
-    namespace UpdateMany {
-    }
-}

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

@@ -1,66 +0,0 @@
-import { ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import type { Collection } from './collection.js';
-import type { Container } from './container.js';
-import { Resource } from './resource.js';
-import { Singleton } from './singleton.js';
-import { Storage } from './storage.js';
-export declare class ContainerClass extends Resource {
-    readonly kind: OpraSchema.Resource.Kind;
-    readonly resources: ResponsiveMap<Resource>;
-    readonly parent?: Container;
-    constructor(owner: ApiDocument | Container, init: Container.InitArguments);
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Container;
-    /**
-     * Returns Resource instance by path. Returns undefined if not found
-     * @param path
-     * @param silent
-     */
-    getResource(path: string, silent: boolean): Resource | undefined;
-    getResource(path: string, silent: true): Resource | undefined;
-    /**
-     * Returns Resource instance by path. Throws error if not found
-     * @param path
-     */
-    getResource(path: string): Resource;
-    getResource(path: string, silent: false): Resource;
-    /**
-     * Returns Collection resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getContainer(path: string): Container;
-    getContainer(path: string, silent: false): Container;
-    getContainer(path: string, silent: true): Container | undefined;
-    getContainer(path: string, silent?: boolean): Container | undefined;
-    /**
-     * Returns Collection resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getCollection(path: string): Collection;
-    getCollection(path: string, silent: false): Collection;
-    getCollection(path: string, silent: true): Collection | undefined;
-    getCollection(path: string, silent?: boolean): Collection | undefined;
-    /**
-     * Returns Singleton resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getSingleton(path: string): Singleton;
-    getSingleton(path: string, silent: false): Singleton;
-    getSingleton(path: string, silent: true): Singleton | undefined;
-    getSingleton(path: string, silent?: boolean): Singleton | undefined;
-    /**
-     * Returns Storage resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getStorage(path: string): Storage;
-    getStorage(path: string, silent: false): Storage;
-    getStorage(path: string, silent: true): Storage | undefined;
-    getStorage(path: string, silent?: boolean): Storage | undefined;
-}

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

@@ -1,37 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import { ActionDecorator } from './action-decorator.js';
-import { CollectionDecorator } from './collection-decorator.js';
-import type { Container } from './container.js';
-import { ResourceDecorator } from './resource-decorator.js';
-export declare function ContainerDecorator(options?: Container.DecoratorOptions): ClassDecorator;
-export interface ContainerDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
-    (options?: Container.DecoratorOptions): ClassDecorator;
-    Action: (options?: CollectionDecorator.Action.Options) => ActionDecorator;
-}
-/**
- * @namespace CollectionDecorator
- */
-export declare namespace ContainerDecorator {
-    interface Metadata extends StrictOmit<OpraSchema.Container, 'kind' | 'actions' | 'resources'> {
-        kind: OpraSchema.Container.Kind;
-        name: string;
-        actions?: Record<string, ResourceDecorator.OperationMetadata>;
-        resources?: Type[];
-    }
-    /**
-     * @namespace Action
-     */
-    namespace Action {
-        interface Metadata extends ResourceDecorator.OperationMetadata {
-        }
-        interface Options extends ResourceDecorator.OperationOptions {
-        }
-    }
-}
-export declare namespace ContainerDecorator {
-    /**
-     * Action PropertyDecorator
-     */
-    function Action(options: ResourceDecorator.OperationOptions): ActionDecorator;
-}

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

@@ -1,27 +0,0 @@
-import { Combine, StrictOmit } from 'ts-gems';
-import type { ApiDocument } from '../api-document.js';
-import { ContainerClass } from './container-class.js';
-import { ContainerDecorator } from './container-decorator.js';
-import type { Resource } from './resource.js';
-export interface Container extends ContainerClass {
-}
-export interface ContainerConstructor extends ContainerDecorator {
-    prototype: ContainerClass;
-    new (parent: ApiDocument | Container, init: Container.InitArguments): ContainerClass;
-}
-/**
- * @class Container
- * @decorator Container
- */
-export declare const Container: ContainerConstructor;
-export declare namespace Container {
-    interface InitArguments extends StrictOmit<Combine<Resource.InitArguments, ContainerDecorator.Metadata>, 'kind' | 'resources'> {
-        resources?: Resource[];
-    }
-    interface DecoratorOptions extends Partial<StrictOmit<ContainerDecorator.Metadata, 'kind' | 'actions'>> {
-    }
-    interface Action {
-    }
-    namespace Action {
-    }
-}

package/types/document/resource/crud-operation-decorator.d.ts

@@ -1,6 +0,0 @@
-import { Type } from 'ts-gems';
-import { ResourceDecorator } from './resource-decorator.js';
-export type CrudOperationDecorator = ((target: Object, propertyKey: any) => void) & {
-    Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => CrudOperationDecorator;
-};
-export declare function createOperationDecorator<T extends CrudOperationDecorator, M extends ResourceDecorator.OperationMetadata>(operation: string, init: any, list: ((operationMeta: M, target: Object, propertyKey: string) => void)[]): T;

package/types/document/resource/crud-operation.d.ts

@@ -1,32 +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 { ApiField } from '../data-type/field.js';
-import { Endpoint } from './endpoint.js';
-import type { Resource } from './resource';
-import type { ResourceDecorator } from './resource-decorator.js';
-/**
- *
- * @class CrudOperation
- */
-export declare class CrudOperation extends Endpoint {
-    readonly resource: Resource;
-    readonly name: string;
-    readonly kind = "operation";
-    decodeInput: Validator;
-    returnType: DataType;
-    encodeReturning: Validator;
-    inputOverwriteFields?: Record<string, ApiField.InitArguments>;
-    outputOverwriteFields?: Record<string, ApiField.InitArguments>;
-    constructor(resource: Resource, name: string, init: CrudOperation.InitArguments);
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Endpoint<any> & Record<string, any>;
-}
-export declare namespace CrudOperation {
-    interface InitArguments extends StrictOmit<ResourceDecorator.OperationMetadata, 'parameters'> {
-        parameters: Record<string, Endpoint.ParameterInit>;
-        returnType?: DataType;
-    }
-}