@opra/common 0.33.13 → 1.0.0-alpha.10

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

@@ -1,35 +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 type { ResourceDecorator } from './resource-decorator.js';
-/**
- *
- * @class Parameter
- */
-export declare class Parameter {
-    protected _decoder: Validator;
-    protected _encoder: Validator;
-    readonly name: string;
-    readonly type: DataType;
-    description?: string;
-    isArray?: boolean;
-    default?: any;
-    required?: boolean;
-    deprecated?: boolean | string;
-    examples?: any[] | Record<string, any>;
-    readonly isBuiltin?: boolean;
-    constructor(name: string, init: Parameter.InitArguments);
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Endpoint.Parameter;
-    getDecoder(): Validator;
-    getEncoder(): Validator;
-    generateCodec(codec: 'decode' | 'encode', options?: DataType.GenerateCodecOptions): Validator;
-}
-export declare namespace Parameter {
-    interface InitArguments extends StrictOmit<ResourceDecorator.ParameterMetadata, 'type'> {
-        type: DataType;
-        isBuiltin?: boolean;
-    }
-}

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

@@ -1,40 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import { TypeThunkAsync } from '../../types.js';
-import { EnumType } from '../data-type/enum-type.js';
-export interface ResourceDecorator {
-    Action: (options?: ResourceDecorator.OperationOptions) => ResourceDecorator;
-}
-export declare function ResourceDecorator<O extends ResourceDecorator.Options>(kind: OpraSchema.Resource.Kind, meta?: O): ClassDecorator;
-/**
- * @namespace ResourceDecorator
- */
-export declare namespace ResourceDecorator {
-    interface Metadata extends StrictOmit<OpraSchema.ResourceBase, 'actions'> {
-        name: string;
-        actions?: Record<string, ActionMetadata>;
-        operations?: Record<string, OperationMetadata>;
-    }
-    interface Options extends Partial<StrictOmit<Metadata, 'kind' | 'actions' | 'operations'>> {
-    }
-    interface ParameterMetadata extends StrictOmit<OpraSchema.Endpoint.Parameter, 'type'> {
-        type?: TypeThunkAsync | string;
-        enum?: EnumType.EnumObject | EnumType.EnumArray;
-    }
-    interface ParameterOptions extends Partial<ParameterMetadata> {
-    }
-    interface OperationMetadata extends StrictOmit<OpraSchema.Endpoint, 'parameters'> {
-        parameters: Record<string, ParameterMetadata>;
-    }
-    interface OperationOptions extends Partial<StrictOmit<OpraSchema.Endpoint, 'parameters'>> {
-        parameters?: Record<string, ParameterOptions>;
-    }
-    interface ActionMetadata extends StrictOmit<OpraSchema.Action, 'parameters' | 'returnType'> {
-        parameters: Record<string, ParameterMetadata>;
-        returnType?: TypeThunkAsync | string;
-    }
-    interface ActionOptions extends Partial<StrictOmit<OpraSchema.Action, 'parameters' | 'returnType'>> {
-        parameters?: Record<string, ParameterOptions>;
-        returnType?: TypeThunkAsync | string;
-    }
-}

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

@@ -1,35 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { nodeInspectCustom } from '../utils/inspect.util.js';
-import { Action } from './action.js';
-import type { Container } from './container.js';
-import { CrudOperation } from './crud-operation.js';
-import type { ResourceDecorator } from './resource-decorator';
-export declare abstract class Resource {
-    readonly document: ApiDocument;
-    readonly parent?: Container;
-    abstract readonly kind: OpraSchema.Resource.Kind;
-    readonly name: string;
-    description?: string;
-    controller?: object;
-    ctor?: Type;
-    actions: ResponsiveMap<Action>;
-    protected constructor(parent: ApiDocument | Container, init: Resource.InitArguments);
-    getFullPath(documentPath?: boolean): string;
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.ResourceBase;
-    toString(): string;
-    [nodeInspectCustom](): string;
-}
-export declare namespace Resource {
-    interface InitArguments extends StrictOmit<ResourceDecorator.Metadata, 'kind' | 'operations' | 'actions'> {
-        name: string;
-        actions?: Record<string, Action.InitArguments>;
-        operations?: Record<string, CrudOperation.InitArguments>;
-        controller?: object;
-        ctor?: Type;
-    }
-}

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

@@ -1,21 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import type { ComplexType } from '../data-type/complex-type.js';
-import type { Container } from './container.js';
-import type { CrudOperation } from './crud-operation';
-import { CrudResource } from './crud-resource.js';
-import type { Singleton } from './singleton.js';
-import type { SingletonDecorator } from './singleton-decorator';
-export declare class SingletonClass extends CrudResource {
-    readonly kind: OpraSchema.Resource.Kind;
-    readonly type: ComplexType;
-    constructor(parent: ApiDocument | Container, init: Singleton.InitArguments);
-    getOperation(name: 'create'): (CrudOperation & Omit<SingletonDecorator.Create.Metadata, keyof CrudOperation>) | undefined;
-    getOperation(name: 'delete'): (CrudOperation & Omit<SingletonDecorator.Delete.Metadata, keyof CrudOperation>) | undefined;
-    getOperation(name: 'get'): (CrudOperation & Omit<SingletonDecorator.Get.Metadata, keyof CrudOperation>) | undefined;
-    getOperation(name: 'update'): (CrudOperation & Omit<SingletonDecorator.Update.Metadata, keyof CrudOperation>) | undefined;
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Singleton;
-    normalizeFieldNames(path: string | string[]): string[] | undefined;
-}

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

@@ -1,131 +0,0 @@
-import { Combine, StrictOmit, Type } from 'ts-gems';
-import { Field } from '../../schema/data-type/field.interface.js';
-import { OpraSchema } from '../../schema/index.js';
-import { TypeThunkAsync } from '../../types.js';
-import { ActionDecorator } from './action-decorator.js';
-import { CollectionDecorator } from './collection-decorator.js';
-import { ResourceDecorator } from './resource-decorator.js';
-import type { Singleton } from './singleton.js';
-type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
-declare const operationProperties: readonly ["create", "delete", "get", "update"];
-type OperationProperties = typeof operationProperties[number];
-export declare function SingletonDecorator(type: Type | string, options?: Singleton.DecoratorOptions): ClassDecorator;
-export interface SingletonDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
-    <T>(type: Type<T> | string, options?: Singleton.DecoratorOptions): ClassDecorator;
-    Action: (options?: SingletonDecorator.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 SingletonDecorator.Create;
-    Delete: typeof SingletonDecorator.Delete;
-    Get: typeof SingletonDecorator.Get;
-    Update: typeof SingletonDecorator.Update;
-}
-/**
- * @namespace SingletonDecorator
- */
-export declare namespace SingletonDecorator {
-    interface Metadata extends StrictOmit<OpraSchema.Singleton, 'kind' | 'type' | 'operations' | 'actions'> {
-        kind: OpraSchema.Singleton.Kind;
-        name: string;
-        type: TypeThunkAsync | string;
-        actions?: Record<string, ResourceDecorator.OperationMetadata>;
-        operations?: {
-            create: Create.Metadata;
-            delete: Delete.Metadata;
-            get: Get.Metadata;
-            update: Update.Metadata;
-        };
-    }
-    /**
-     * @namespace Action
-     */
-    namespace Action {
-        interface Metadata extends ResourceDecorator.OperationMetadata {
-        }
-        interface Options extends ResourceDecorator.OperationOptions {
-        }
-    }
-    /**
-     * @namespace Create
-     */
-    namespace Create {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Singleton.Operations.Create> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Singleton.Operations.Create>> {
-        }
-    }
-    /**
-     * @namespace Delete
-     */
-    namespace Delete {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Singleton.Operations.Delete> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Singleton.Operations.Delete>> {
-        }
-    }
-    /**
-     * @namespace Get
-     */
-    namespace Get {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Singleton.Operations.Get> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Singleton.Operations.Get>> {
-        }
-    }
-    /**
-     * @namespace Update
-     */
-    namespace Update {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Singleton.Operations.Update> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Singleton.Operations.Update>> {
-        }
-    }
-}
-export declare namespace SingletonDecorator {
-    /**
-     * 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, CollectionDecorator.FieldDecoratorOptions>) => CreateDecorator;
-        OutputPickFields: (...fields: Field.QualifiedName[]) => CreateDecorator;
-        OutputOmitFields: (...fields: Field.QualifiedName[]) => CreateDecorator;
-        OutputOverwriteFields: (fields: Record<string, CollectionDecorator.FieldDecoratorOptions>) => CreateDecorator;
-    };
-    function Create(options?: Create.Options): CreateDecorator;
-}
-export declare namespace SingletonDecorator {
-    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, CollectionDecorator.FieldDecoratorOptions>) => GetDecorator;
-    };
-    function Get(options?: Get.Options): GetDecorator;
-}
-export declare namespace SingletonDecorator {
-    type DeleteDecorator = ((target: Object, propertyKey: 'delete') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => DeleteDecorator;
-    };
-    function Delete(options?: Delete.Options): DeleteDecorator;
-}
-export declare namespace SingletonDecorator {
-    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, CollectionDecorator.FieldDecoratorOptions>) => UpdateDecorator;
-        OutputPickFields: (...fields: Field.QualifiedName[]) => UpdateDecorator;
-        OutputOmitFields: (...fields: Field.QualifiedName[]) => UpdateDecorator;
-        OutputOverwriteFields: (fields: Record<string, CollectionDecorator.FieldDecoratorOptions>) => UpdateDecorator;
-    };
-    function Update(options?: Update.Options): UpdateDecorator;
-}
-export {};

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

@@ -1,49 +0,0 @@
-import { Combine, StrictOmit } from 'ts-gems';
-import type { ApiDocument } from '../api-document.js';
-import type { ComplexType } from '../data-type/complex-type.js';
-import type { Container } from './container.js';
-import type { Resource } from './resource.js';
-import { SingletonClass } from './singleton-class.js';
-import { SingletonDecorator } from './singleton-decorator.js';
-export interface Singleton extends SingletonClass {
-}
-export interface SingletonConstructor extends SingletonDecorator {
-    prototype: SingletonClass;
-    new (parent: ApiDocument | Container, init: Singleton.InitArguments): SingletonClass;
-}
-/**
- * @class Singleton
- * @decorator Singleton
- */
-export declare const Singleton: SingletonConstructor;
-/**
- * @namespace Singleton
- */
-export declare namespace Singleton {
-    interface InitArguments extends StrictOmit<Combine<Resource.InitArguments, SingletonDecorator.Metadata>, 'kind' | 'type'> {
-        name: string;
-        type: ComplexType;
-    }
-    interface DecoratorOptions extends Partial<StrictOmit<SingletonDecorator.Metadata, 'kind' | 'operations' | 'actions'>> {
-    }
-    interface Action {
-    }
-    namespace Action {
-    }
-    interface Create {
-    }
-    namespace Create {
-    }
-    interface Delete {
-    }
-    namespace Delete {
-    }
-    interface Get {
-    }
-    namespace Get {
-    }
-    interface Update {
-    }
-    namespace Update {
-    }
-}

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

@@ -1,17 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import type { Container } from './container';
-import type { CrudOperation } from './crud-operation.js';
-import { CrudResource } from './crud-resource.js';
-import type { Storage } from './storage.js';
-import type { StorageDecorator } from './storage-decorator';
-export declare class StorageClass extends CrudResource {
-    readonly kind: OpraSchema.Resource.Kind;
-    constructor(parent: ApiDocument | Container, init: Storage.InitArguments);
-    getOperation(name: 'delete'): (CrudOperation & Omit<StorageDecorator.Delete.Metadata, keyof CrudOperation>) | undefined;
-    getOperation(name: 'get'): (CrudOperation & Omit<StorageDecorator.Get.Metadata, keyof CrudOperation>) | undefined;
-    getOperation(name: 'post'): (CrudOperation & Omit<StorageDecorator.Post.Metadata, keyof CrudOperation>) | undefined;
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Storage;
-}

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

@@ -1,100 +0,0 @@
-import { Combine, StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import { TypeThunkAsync } from '../../types.js';
-import { ActionDecorator } from './action-decorator.js';
-import { ResourceDecorator } from './resource-decorator.js';
-import type { Storage } from './storage.js';
-type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
-declare const operationProperties: readonly ["delete", "get", "post"];
-type OperationProperties = typeof operationProperties[number];
-export declare function StorageDecorator(options?: Storage.DecoratorOptions): ClassDecorator;
-export interface StorageDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
-    (options?: Storage.DecoratorOptions): ClassDecorator;
-    Action: (options?: StorageDecorator.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;
-    Delete: typeof StorageDecorator.Delete;
-    Get: typeof StorageDecorator.Get;
-    Post: typeof StorageDecorator.Post;
-}
-/**
- * @namespace CollectionDecorator
- */
-export declare namespace StorageDecorator {
-    interface Metadata extends StrictOmit<OpraSchema.Storage, 'kind' | 'operations' | 'actions'> {
-        kind: OpraSchema.Storage.Kind;
-        name: string;
-        actions?: Record<string, ResourceDecorator.OperationMetadata>;
-        operations?: {
-            get: Get.Metadata;
-            delete: Delete.Metadata;
-            post: Post.Metadata;
-        };
-    }
-    /**
-     * @namespace Action
-     */
-    namespace Action {
-        interface Metadata extends ResourceDecorator.OperationMetadata {
-        }
-        interface Options extends ResourceDecorator.OperationOptions {
-        }
-    }
-    /**
-     * @namespace Get
-     */
-    namespace Get {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Storage.Operations.Get> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Storage.Operations.Get>> {
-        }
-    }
-    /**
-     * @namespace Delete
-     */
-    namespace Delete {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Storage.Operations.Delete> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Storage.Operations.Delete>> {
-        }
-    }
-    /**
-     * @namespace Post
-     */
-    namespace Post {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Storage.Operations.Post> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Storage.Operations.Post>> {
-        }
-    }
-}
-export declare namespace StorageDecorator {
-    /**
-     * Action PropertyDecorator
-     */
-    function Action(options: ResourceDecorator.OperationOptions): ActionDecorator;
-    type DeleteDecorator = ((target: Object, propertyKey: 'delete') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => DeleteDecorator;
-    };
-    function Delete(options?: Delete.Options): DeleteDecorator;
-    /**
-     * Get PropertyDecorator
-     */
-    type GetDecorator = ((target: Object, propertyKey: 'get') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => GetDecorator;
-    };
-    function Get(options?: Get.Options): GetDecorator;
-    /**
-     * Post PropertyDecorator
-     */
-    type PostDecorator = ((target: Object, propertyKey: 'post') => void) & {
-        Parameter(name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type): PostDecorator;
-        MaxFields(amount: number): PostDecorator;
-        MaxFieldSize(sizeInBytes: number): PostDecorator;
-        MaxFiles(amount: number): PostDecorator;
-        MaxFileSize(sizeInBytes: number): PostDecorator;
-        MaxTotalFileSize(sizeInBytes: number): PostDecorator;
-        MinFileSize(sizeInBytes: number): PostDecorator;
-        Returns(t: TypeThunkAsync | string): PostDecorator;
-    };
-    function Post(options?: Post.Options): PostDecorator;
-}
-export {};

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

@@ -1,39 +0,0 @@
-import { Combine, StrictOmit } from 'ts-gems';
-import type { ApiDocument } from '../api-document.js';
-import type { Container } from './container.js';
-import type { Resource } from './resource.js';
-import { StorageClass } from './storage-class.js';
-import { StorageDecorator } from './storage-decorator.js';
-export interface Storage extends StorageClass {
-}
-export interface StorageConstructor extends StorageDecorator {
-    prototype: StorageClass;
-    new (parent: ApiDocument | Container, init: Storage.InitArguments): StorageClass;
-}
-/**
- * @class Storage
- * @decorator Storage
- */
-export declare const Storage: StorageConstructor;
-export declare namespace Storage {
-    interface InitArguments extends StrictOmit<Combine<Resource.InitArguments, StorageDecorator.Metadata>, 'kind'> {
-    }
-    interface DecoratorOptions extends Partial<StrictOmit<StorageDecorator.Metadata, 'kind' | 'operations' | 'actions'>> {
-    }
-    interface Action {
-    }
-    namespace Action {
-    }
-    interface Delete {
-    }
-    namespace Delete {
-    }
-    interface Get {
-    }
-    namespace Get {
-    }
-    interface Post {
-    }
-    namespace Post {
-    }
-}

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

@@ -1,79 +0,0 @@
-import { Type } from 'ts-gems';
-import { ResponsiveMap } from '../helpers/index.js';
-import { OpraSchema } from '../schema/index.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 { SimpleType } from './data-type/simple-type.js';
-import { DocumentBase } from './document-base.js';
-export declare class TypeDocument extends DocumentBase {
-    protected _designCtorMap: Map<Function | Type<any>, string>;
-    protected _typeIndex: Map<string | object | Type<any>, DataType>;
-    protected _typeNsMap: Map<DataType, string>;
-    references: ResponsiveMap<TypeDocument>;
-    types: ResponsiveMap<DataType>;
-    constructor();
-    /**
-     * Returns DataType instance by name or Constructor. Returns undefined if not found
-     * @param nameOrCtor
-     * @param silent
-     */
-    getDataType(nameOrCtor: any, silent: true): DataType | undefined;
-    /**
-     * Returns DataType instance by name or Constructor. Throws error  if not found
-     * @param nameOrCtor
-     */
-    getDataType(nameOrCtor: any): DataType;
-    /**
-     * Returns NS of datatype. Returns undefined if not found
-     * @param nameOrCtor
-     * @param silent
-     */
-    getDataTypeNs(nameOrCtor: any, silent: true): string | undefined;
-    /**
-     * Returns NS of datatype. Throws error  if not found
-     * @param nameOrCtor
-     */
-    getDataTypeNs(nameOrCtor: any): string;
-    /**
-     * Returns ComplexType instance by name or Constructor.
-     * Returns undefined if not found
-     * Throws error if data type is not a ComplexType
-     * @param nameOrCtor
-     * @param silent
-     */
-    getComplexType(nameOrCtor: string | Type, silent: true): ComplexType | undefined;
-    /**
-     * Returns ComplexType instance by name or Constructor.
-     * Throws error undefined if not found or data type is not a ComplexType
-     * @param nameOrCtor
-     */
-    getComplexType(nameOrCtor: string | Type): ComplexType;
-    /**
-     * Returns SimpleType instance by name or Constructor.
-     * Returns undefined if not found
-     * Throws error if data type is not a SimpleType
-     * @param nameOrCtor
-     * @param silent
-     */
-    getSimpleType(nameOrCtor: string | Type, silent: true): SimpleType | undefined;
-    /**
-     Returns SimpleType instance by name or Constructor.
-     Throws error undefined if not found or data type is not a SimpleType
-     * @param nameOrCtor
-     */
-    getSimpleType(nameOrCtor: string | Type): SimpleType;
-    /**
-     Returns SimpleType instance by name or Constructor.
-     Throws error undefined if not found or data type is not a SimpleType
-     * @param nameOrCtor
-     */
-    getEnumType(nameOrCtor: string | EnumType.EnumObject | EnumType.EnumArray): EnumType;
-    /**
-     * Export as Opra schema definition object
-     */
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.TypeDocument;
-    invalidate(): void;
-}

package/types/exception/resource-errors/resource-conflict.error.d.ts

@@ -1,5 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-export declare class ResourceConflictError extends OpraException {
-    status: number;
-    constructor(resource: string, fields: string | string[], cause?: Error);
-}

package/types/exception/wrap-exception.d.ts

@@ -1,2 +0,0 @@
-import { OpraException } from './opra-exception.js';
-export declare function wrapException(error: any): OpraException;

package/types/helpers/is-url-string.d.ts

@@ -1,2 +0,0 @@
-export declare function isUrlString(url: string): boolean;
-export declare const isAbsoluteUrl: (urlString: string) => boolean;

package/types/helpers/path-to-object-tree.d.ts

@@ -1,4 +0,0 @@
-export interface ObjectTree {
-    [key: string]: boolean | ObjectTree;
-}
-export declare function pathToObjectTree(arr: string[], lowerCaseKeys?: boolean): ObjectTree | undefined;

package/types/http/opra-url-path.d.ts

@@ -1,55 +0,0 @@
-declare const nodeInspectCustom: unique symbol;
-declare const kLength: unique symbol;
-type ResourceKey = Record<string, string | number | boolean | null>;
-/**
- * @class OpraURLPath
- */
-export declare class OpraURLPath {
-    protected [kLength]: number;
-    [index: number]: OpraURLPathComponent;
-    constructor(...init: (OpraURLPath.ComponentLike | null | undefined)[]);
-    get length(): number;
-    slice(start?: number, end?: number): OpraURLPath;
-    resolve(...items: OpraURLPath.ComponentLike[]): this;
-    join(...items: OpraURLPath.ComponentLike[]): OpraURLPath;
-    isRelativeTo(basePath: string | OpraURLPath): boolean;
-    forEach(callback: (component: OpraURLPathComponent, index: number, _this: this) => void): void;
-    values(): IterableIterator<OpraURLPathComponent>;
-    toString(): string;
-    [nodeInspectCustom](): string;
-    [Symbol.iterator](): IterableIterator<OpraURLPathComponent>;
-    protected _resolve(items: OpraURLPath.ComponentLike | OpraURLPath.ComponentLike[], join?: boolean): void;
-    static join(...items: OpraURLPath.ComponentLike[]): OpraURLPath;
-    static resolve(...items: OpraURLPath.ComponentLike[]): OpraURLPath;
-    static relative(source: string | OpraURLPath, basePath: string | OpraURLPath): OpraURLPath | undefined;
-}
-export declare namespace OpraURLPath {
-    type ComponentLike = string | OpraURLPath | OpraURLPathComponent | OpraURLPathComponent.Initiator;
-}
-/**
- *
- * @class OpraURLPathComponent
- */
-export declare class OpraURLPathComponent {
-    resource: string;
-    key?: string | number | ResourceKey;
-    args?: Record<string, any>;
-    typeCast?: string;
-    constructor(init: OpraURLPathComponent.Initiator);
-    toString(): string;
-    [nodeInspectCustom](): string;
-    /**
-     * Factory method.
-     * @param input
-     */
-    static parse(input: string): OpraURLPathComponent;
-}
-export declare namespace OpraURLPathComponent {
-    interface Initiator {
-        resource: string;
-        key?: string | number | ResourceKey;
-        args?: Record<string, any>;
-        typeCast?: string;
-    }
-}
-export {};