@opra/client 0.17.1 → 0.17.2

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

@@ -1,53 +0,0 @@
-import { Class, StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexType } from './complex-type.js';
-import { DataType } from './data-type.js';
-/**
- * @namespace MappedType
- */
-export declare namespace MappedType {
-    interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.MappedType, 'pick' | 'omit'> {
-        type: ComplexType;
-    }
-    interface OwnProperties extends DataType.OwnProperties, Pick<OpraSchema.MappedType, 'pick' | 'omit'> {
-        type: ComplexType;
-    }
-    interface Options<T, K = keyof T> {
-        pick?: readonly K[];
-        omit?: readonly K[];
-    }
-    interface Metadata extends StrictOmit<OpraSchema.MappedType, 'type'> {
-        type: Type;
-    }
-}
-/**
- * Type definition of MappedType prototype
- * @type MappedType
- */
-export interface MappedType extends StrictOmit<DataType, 'own' | 'exportSchema'>, Pick<ComplexType, 'additionalFields' | 'fields'>, MappedType.OwnProperties {
-    readonly own: MappedType.OwnProperties;
-    readonly type: ComplexType;
-    exportSchema(): OpraSchema.MappedType;
-}
-/**
- * Type definition of MappedType constructor type
- * @type MappedTypeConstructor
- */
-export interface MappedTypeConstructor {
-    prototype: MappedType;
-    new (document: ApiDocument, init: MappedType.InitArguments): MappedType;
-    <T extends any[], I1, S1, PickKey extends keyof I1, OmitKey extends keyof I1>(source: Class<T, I1, S1>, options: {
-        pickKeys?: readonly PickKey[];
-        omitKeys?: readonly OmitKey[];
-    }): Class<T, Omit<Pick<I1, PickKey>, OmitKey>>;
-    _applyMixin(target: Type, source: Type, options: MappedType.Options<any> & {
-        isInheritedPredicate: (fieldName: string) => boolean;
-    }): void;
-}
-/**
- * @class MappedType
- */
-export declare const MappedType: MappedTypeConstructor;
-export declare function PickType<T extends any[], I1, S1, K extends keyof I1>(classRef: Class<T, I1, S1>, keys: readonly K[]): Class<T, Pick<I1, K>> & Omit<Pick<S1, keyof typeof classRef>, 'prototype' | 'constructor'>;
-export declare function OmitType<T extends any[], I1, S1, K extends keyof I1>(classRef: Class<T, I1, S1>, keys: readonly K[]): Class<T, Omit<I1, K>> & Omit<Pick<S1, keyof typeof classRef>, 'prototype' | 'constructor'>;

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

@@ -1,33 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { DataType } from './data-type.js';
-export declare namespace SimpleType {
-    interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.SimpleType, 'ctor' | 'pattern' | 'codec'> {
-        base?: SimpleType;
-    }
-    interface OwnProperties extends DataType.OwnProperties, Readonly<Pick<OpraSchema.SimpleType, 'ctor' | 'pattern' | 'codec'>> {
-    }
-    interface DecoratorOptions extends DataType.DecoratorOptions, Pick<InitArguments, 'ctor' | 'pattern'> {
-    }
-    interface Metadata extends OpraSchema.SimpleType {
-        name: string;
-    }
-}
-export interface SimpleType extends StrictOmit<DataType, 'own' | 'exportSchema'>, SimpleType.OwnProperties {
-    readonly ctor: Type;
-    readonly base?: SimpleType;
-    readonly own: SimpleType.OwnProperties;
-    exportSchema(): OpraSchema.SimpleType;
-    decode(value: any): any;
-    encode(value: any): any;
-}
-export interface SimpleTypeConstructor {
-    new (document: ApiDocument, init?: SimpleType.InitArguments): SimpleType;
-    (init?: SimpleType.DecoratorOptions): ClassDecorator;
-    prototype: SimpleType;
-}
-/**
- * @class SimpleType
- */
-export declare const SimpleType: SimpleTypeConstructor;

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

@@ -1,42 +0,0 @@
-import { Class, StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexType } from './complex-type.js';
-import { DataType } from './data-type.js';
-import { MappedType } from './mapped-type.js';
-/**
- * @namespace UnionType
- */
-export declare namespace UnionType {
-    interface InitArguments extends DataType.InitArguments {
-        types: (ComplexType | UnionType | MappedType)[];
-    }
-    interface OwnProperties extends DataType.OwnProperties {
-        types: (ComplexType | UnionType | MappedType)[];
-    }
-    interface Metadata extends StrictOmit<OpraSchema.UnionType, 'types'> {
-        types: Type[];
-    }
-}
-/**
- * Type definition of UnionType prototype
- * @type UnionType
- */
-export interface UnionType extends StrictOmit<DataType, 'own' | 'exportSchema'>, Pick<ComplexType, 'additionalFields' | 'fields'>, UnionType.OwnProperties {
-    readonly own: UnionType.OwnProperties;
-    exportSchema(): OpraSchema.UnionType;
-}
-/**
- * Type definition of UnionType constructor type
- * @type UnionTypeConstructor
- */
-export interface UnionTypeConstructor {
-    prototype: UnionType;
-    new (document: ApiDocument, init: UnionType.InitArguments): UnionType;
-    <A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3, A4 extends any[], I4, S4>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, c4?: Class<A4, I4, S4>): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;
-    _applyMixin(target: Type, ...sources: [Type]): void;
-}
-/**
- * @class UnionType
- */
-export declare const UnionType: UnionTypeConstructor;

package/types/common/document/factory/add-references.d.ts

@@ -1,4 +0,0 @@
-import type { OpraSchema } from '../../schema/index.js';
-import { ApiDocument } from '../api-document.js';
-import type { DocumentFactory } from './factory.js';
-export declare function addReferences(this: DocumentFactory, references: Record<string, string | OpraSchema.ApiDocument | ApiDocument>): Promise<void>;

package/types/common/document/factory/create-document.d.ts

@@ -1,12 +0,0 @@
-import { ApiDocument } from '../api-document.js';
-import type { DocumentFactory } from './factory.js';
-export declare function createDocument(this: DocumentFactory, init: DocumentFactory.InitArguments, options?: {
-    noBuiltinTypes?: boolean;
-}): Promise<ApiDocument>;
-/**
- *
- * @param url
- * @protected
- */
-export declare function createDocumentFromUrl(this: DocumentFactory, url: string): Promise<ApiDocument>;
-export declare function createBuiltinTypeDocument(this: DocumentFactory): Promise<ApiDocument>;

package/types/common/document/factory/factory.d.ts

@@ -1,61 +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 { 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 { createCollection, createSingleton, processResourceQueue } from './process-resources.js';
-import { addDataType, createDataTypeInstance, processTypes } from './process-types.js';
-/**
- * @namespace DocumentFactory
- */
-export declare namespace DocumentFactory {
-    type InitArguments = StrictOmit<OpraSchema.ApiDocument, 'references' | 'types' | 'resources'> & {
-        references?: Record<string, string | OpraSchema.ApiDocument | ApiDocument>;
-        resources?: ThunkAsync<Type | object>[] | Record<OpraSchema.Resource.Name, OpraSchema.Resource>;
-        types?: ThunkAsync<Type | OpraSchema.EnumThunk>[] | Record<string, OpraSchema.DataType>;
-    };
-}
-/**
- * @class DocumentFactory
- */
-export declare class DocumentFactory {
-    protected document: ApiDocument;
-    protected typeQueue: ResponsiveMap<OpraSchema.DataType>;
-    protected resourceQueue: ResponsiveMap<OpraSchema.Resource>;
-    protected circularRefs: ResponsiveMap<any>;
-    protected curPath: string[];
-    protected cache: Map<any, any>;
-    protected createDocument: typeof createDocument;
-    protected createDocumentFromUrl: typeof createDocumentFromUrl;
-    protected createBuiltinTypeDocument: typeof createBuiltinTypeDocument;
-    protected addReferences: typeof addReferences;
-    protected importTypeClass: typeof importTypeClass;
-    protected extractSimpleTypeSchema: typeof extractSimpleTypeSchema;
-    protected extractComplexTypeSchema: typeof extractComplexTypeSchema;
-    protected extractMappedTypeSchema: typeof extractMappedTypeSchema;
-    protected extractUnionTypeSchema: typeof extractUnionTypeSchema;
-    protected extractEnumTypeSchema: typeof extractEnumTypeSchema;
-    protected extractFieldSchema: typeof extractFieldSchema;
-    protected processTypes: typeof processTypes;
-    protected createDataTypeInstance: typeof createDataTypeInstance;
-    protected addDataType: typeof addDataType;
-    protected importResourceClass: typeof importResourceClass;
-    protected extractSingletonSchema: typeof extractSingletonSchema;
-    protected extractCollectionSchema: typeof extractCollectionSchema;
-    protected processResourceQueue: typeof processResourceQueue;
-    protected createCollection: typeof createCollection;
-    protected createSingleton: typeof createSingleton;
-    /**
-     * Creates ApiDocument instance from given schema object
-     * @param init
-     */
-    static createDocument(init: DocumentFactory.InitArguments): Promise<ApiDocument>;
-    /**
-     * Downloads schema from the given URL and creates the document instance   * @param url
-     */
-    static createDocumentFromUrl(url: string): Promise<ApiDocument>;
-}

package/types/common/document/factory/import-resource-class.d.ts

@@ -1,10 +0,0 @@
-import 'reflect-metadata';
-import { Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import type { ThunkAsync } from '../../types.js';
-import type { Collection } from '../resource/collection.js';
-import type { Singleton } from '../resource/singleton.js';
-import type { DocumentFactory } from './factory.js';
-export declare function importResourceClass(this: DocumentFactory, thunk: ThunkAsync<Type | object>): Promise<void>;
-export declare function extractSingletonSchema(this: DocumentFactory, target: OpraSchema.Singleton, ctor: Type, metadata: Singleton.Metadata, controller: object | Type): Promise<void>;
-export declare function extractCollectionSchema(this: DocumentFactory, target: OpraSchema.Collection, ctor: Type, metadata: Collection.Metadata, controller: object | Type): Promise<void>;

package/types/common/document/factory/import-type-class.d.ts

@@ -1,17 +0,0 @@
-import { Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import type { ThunkAsync } from '../../types.js';
-import type { ApiField } from '../data-type/api-field.js';
-import type { ComplexType } from '../data-type/complex-type.js';
-import type { EnumType } from '../data-type/enum-type.js';
-import type { MappedType } from '../data-type/mapped-type.js';
-import type { SimpleType } from '../data-type/simple-type.js';
-import type { UnionType } from '../data-type/union-type.js';
-import type { DocumentFactory } from './factory.js';
-export declare function importTypeClass(this: DocumentFactory, typeThunk: ThunkAsync<Type | OpraSchema.EnumThunk>): Promise<string | OpraSchema.DataType>;
-export declare function extractSimpleTypeSchema(this: DocumentFactory, target: OpraSchema.SimpleType, ctor: Type, metadata: SimpleType.Metadata): Promise<void>;
-export declare function extractComplexTypeSchema(this: DocumentFactory, target: OpraSchema.ComplexType, ctor: Type, metadata: ComplexType.Metadata): Promise<void>;
-export declare function extractMappedTypeSchema(this: DocumentFactory, target: OpraSchema.MappedType, ctor: Type, metadata: MappedType.Metadata): Promise<void>;
-export declare function extractUnionTypeSchema(this: DocumentFactory, target: OpraSchema.UnionType, ctor: Type, metadata: UnionType.Metadata): Promise<void>;
-export declare function extractEnumTypeSchema(this: DocumentFactory, target: OpraSchema.EnumType, enumObject: any, metadata: EnumType.Metadata): Promise<void>;
-export declare function extractFieldSchema(this: DocumentFactory, target: OpraSchema.Field, ctor: Type, metadata: ApiField.Metadata, name: string): Promise<void>;

package/types/common/document/factory/index.d.ts

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

package/types/common/document/factory/process-resources.d.ts

@@ -1,7 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import { Collection } from '../resource/collection.js';
-import { Singleton } from '../resource/singleton.js';
-import type { DocumentFactory } from './factory.js';
-export declare function processResourceQueue(this: DocumentFactory): Promise<void>;
-export declare function createCollection(this: DocumentFactory, name: string, schema: OpraSchema.Collection): Promise<Collection>;
-export declare function createSingleton(this: DocumentFactory, name: string, schema: OpraSchema.Singleton): Promise<Singleton>;

package/types/common/document/factory/process-types.d.ts

@@ -1,6 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import { DataType } from '../data-type/data-type.js';
-import type { DocumentFactory } from './factory.js';
-export declare function processTypes(this: DocumentFactory): Promise<void>;
-export declare function createDataTypeInstance(this: DocumentFactory, kind: OpraSchema.DataType.Kind, name?: string): DataType;
-export declare function addDataType(this: DocumentFactory, schemaOrName: OpraSchema.DataType | string): DataType;

package/types/common/document/index.d.ts

@@ -1,14 +0,0 @@
-import 'reflect-metadata';
-export * from './constants.js';
-export * from './api-document.js';
-export * from './factory/index.js';
-export * from './data-type/data-type.js';
-export * from './data-type/complex-type.js';
-export * from './data-type/api-field.js';
-export * from './data-type/enum-type.js';
-export * from './data-type/mapped-type.js';
-export * from './data-type/simple-type.js';
-export * from './data-type/union-type.js';
-export * from './resource/resource.js';
-export * from './resource/collection.js';
-export * from './resource/singleton.js';

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

@@ -1,69 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { Expression } from '../../filter/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import type { TypeThunkAsync } from '../../types.js';
-import type { ApiDocument } from '../api-document.js';
-import type { ComplexType } from '../data-type/complex-type.js';
-import { Resource } from './resource.js';
-export declare namespace Collection {
-    export interface InitArguments extends Resource.InitArguments, Pick<OpraSchema.Collection, 'primaryKey'> {
-        type: ComplexType;
-        operations: Operations;
-    }
-    export interface DecoratorOptions extends Resource.DecoratorOptions, Partial<Pick<OpraSchema.Collection, 'primaryKey'>> {
-    }
-    export interface Metadata extends StrictOmit<OpraSchema.Collection, 'type'> {
-        name: string;
-        type: TypeThunkAsync | string;
-    }
-    interface Operation {
-        handlerName?: string;
-    }
-    export interface Operations {
-        create?: OpraSchema.Collection.CreateOperation & Operation;
-        delete?: OpraSchema.Collection.DeleteOperation & Operation;
-        get?: OpraSchema.Collection.GetOperation & Operation;
-        update?: OpraSchema.Collection.UpdateOperation & Operation;
-        deleteMany?: OpraSchema.Collection.DeleteManyOperation & Operation;
-        findMany?: OpraSchema.Collection.FindManyOperation & Operation;
-        updateMany?: OpraSchema.Collection.UpdateManyOperation & Operation;
-    }
-    export type CreateOperationOptions = StrictOmit<OpraSchema.Collection.CreateOperation, 'handler'>;
-    export type DeleteOperationOptions = StrictOmit<OpraSchema.Collection.DeleteOperation, 'handler'>;
-    export type DeleteManyOperationOptions = StrictOmit<OpraSchema.Collection.DeleteManyOperation, 'handler'>;
-    export type FindManyOperationOptions = StrictOmit<OpraSchema.Collection.FindManyOperation, 'handler'>;
-    export type GetOperationOptions = StrictOmit<OpraSchema.Collection.GetOperation, 'handler'>;
-    export type UpdateOperationOptions = StrictOmit<OpraSchema.Collection.UpdateOperation, 'handler'>;
-    export type UpdateManyOperationOptions = StrictOmit<OpraSchema.Collection.UpdateManyOperation, 'handler'>;
-    export {};
-}
-export interface Collection extends StrictOmit<Resource, 'exportSchema' | '_construct'> {
-    readonly type: ComplexType;
-    readonly operations: Collection.Operations;
-    readonly controller?: object;
-    readonly primaryKey: string[];
-    exportSchema(): OpraSchema.Collection;
-    parseKeyValue(value: any): any;
-    normalizeFieldPath(fields: string): string;
-    normalizeFieldPath(fields: string[]): string[];
-    normalizeFieldPath(fields: string | string[]): string | string[];
-    normalizeSortFields(fields: string | string[]): string[];
-    normalizeFilter(ast: Expression): Expression;
-    _construct(init: Collection.InitArguments): void;
-}
-export interface CollectionConstructor {
-    prototype: Collection;
-    new (document: ApiDocument, init: Collection.InitArguments): Collection;
-    (type: TypeThunkAsync | string, options?: Collection.DecoratorOptions): ClassDecorator;
-    Create: (options?: Collection.CreateOperationOptions) => PropertyDecorator;
-    Delete: (options?: Collection.DeleteOperationOptions) => PropertyDecorator;
-    Get: (options?: Collection.GetOperationOptions) => PropertyDecorator;
-    Update: (options?: Collection.UpdateOperationOptions) => PropertyDecorator;
-    FindMany: (options?: Collection.FindManyOperationOptions) => PropertyDecorator;
-    DeleteMany: (options?: Collection.DeleteManyOperationOptions) => PropertyDecorator;
-    UpdateMany: (options?: Collection.UpdateManyOperationOptions) => PropertyDecorator;
-}
-/**
- *
- */
-export declare const Collection: CollectionConstructor;

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

@@ -1,29 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { nodeInspectCustom } from '../utils/inspect.util.js';
-export declare namespace Resource {
-    interface InitArguments extends StrictOmit<OpraSchema.ResourceBase, 'kind'> {
-        name: string;
-        controller?: object | Type;
-    }
-    interface DecoratorOptions extends Partial<Pick<InitArguments, 'name' | 'description'>> {
-    }
-}
-export interface Resource {
-    readonly document: ApiDocument;
-    readonly kind: OpraSchema.Resource.Kind;
-    readonly name: string;
-    readonly description?: string;
-    readonly controller?: object | Type;
-    exportSchema(): OpraSchema.ResourceBase;
-    toString(): string;
-    [nodeInspectCustom](): string;
-    _construct(init: Resource.InitArguments): void;
-}
-export interface ResourceConstructor {
-    readonly prototype: Resource;
-    new (document: ApiDocument, init: Resource.InitArguments): Resource;
-    (...args: any[]): void;
-}
-export declare const Resource: ResourceConstructor;

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

@@ -1,51 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import type { TypeThunkAsync } from '../../types.js';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import { Resource } from './resource.js';
-export declare namespace Singleton {
-    export interface InitArguments extends Resource.InitArguments, Pick<OpraSchema.Singleton, 'operations'> {
-        type: ComplexType;
-    }
-    export interface DecoratorOptions extends Resource.DecoratorOptions {
-    }
-    export interface Metadata extends StrictOmit<OpraSchema.Singleton, 'type'> {
-        name: string;
-        type: TypeThunkAsync | string;
-    }
-    interface Operation {
-        handlerName?: string;
-    }
-    export interface Operations {
-        create?: OpraSchema.Singleton.CreateOperation & Operation;
-        delete?: OpraSchema.Singleton.DeleteOperation & Operation;
-        get?: OpraSchema.Singleton.GetOperation & Operation;
-        update?: OpraSchema.Singleton.UpdateOperation & Operation;
-    }
-    export type CreateOperationOptions = StrictOmit<OpraSchema.Singleton.CreateOperation, 'handler'>;
-    export type DeleteOperationOptions = StrictOmit<OpraSchema.Singleton.DeleteOperation, 'handler'>;
-    export type GetOperationOptions = StrictOmit<OpraSchema.Singleton.GetOperation, 'handler'>;
-    export type UpdateOperationOptions = StrictOmit<OpraSchema.Singleton.UpdateOperation, 'handler'>;
-    export {};
-}
-export interface Singleton extends StrictOmit<Resource, 'exportSchema' | '_construct'> {
-    readonly type: ComplexType;
-    readonly operations: Singleton.Operations;
-    readonly controller?: object | Type;
-    exportSchema(): OpraSchema.Singleton;
-    normalizeFieldPath(fields: string): string;
-    normalizeFieldPath(fields: string[]): string[];
-    normalizeFieldPath(fields: string | string[]): string | string[];
-    _construct(init: Singleton.InitArguments): void;
-}
-export interface SingletonConstructor {
-    prototype: Singleton;
-    new (document: ApiDocument, init: Singleton.InitArguments): Singleton;
-    (type: TypeThunkAsync | string, options?: Singleton.DecoratorOptions): ClassDecorator;
-    Create: (options?: Singleton.CreateOperationOptions) => PropertyDecorator;
-    Delete: (options?: Singleton.DeleteOperationOptions) => PropertyDecorator;
-    Get: (options?: Singleton.GetOperationOptions) => PropertyDecorator;
-    Update: (options?: Singleton.UpdateOperationOptions) => PropertyDecorator;
-}
-export declare const Singleton: SingletonConstructor;

package/types/common/document/utils/inspect.util.d.ts

@@ -1,4 +0,0 @@
-export declare const nodeInspectCustom: unique symbol;
-export declare const colorReset = "\u001B[0m";
-export declare const colorFgYellow = "\u001B[33m";
-export declare const colorFgMagenta = "\u001B[35m";

package/types/common/document/utils/string-compare.util.d.ts

@@ -1 +0,0 @@
-export declare function stringCompare(a: string, b: string): number;

package/types/common/exception/enums/issue-severity.enum.d.ts

@@ -1,13 +0,0 @@
-export declare namespace IssueSeverity {
-    enum Enum {
-        'fatal' = "fatal",
-        'error' = "error",
-        'warning' = "warning",
-        'info' = "info"
-    }
-    const name = "IssueSeverity";
-    const description = "Severity of the issue";
-    const Keys: string[];
-    type Type = keyof typeof Enum;
-    const descriptions: Record<Enum, string>;
-}

package/types/common/exception/error-issue.d.ts

@@ -1,9 +0,0 @@
-import { IssueSeverity } from './enums/issue-severity.enum.js';
-export interface ErrorIssue {
-    message: string;
-    severity: IssueSeverity.Type;
-    code?: string;
-    details?: any;
-    diagnostics?: string | string[];
-    debugInfo?: string;
-}

package/types/common/exception/http-errors/bad-request.error.d.ts

@@ -1,10 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-/**
- * 400 Bad Request
- * The server cannot or will not process the request due to something that is perceived to be a client error
- * (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
- */
-export declare class BadRequestError extends OpraException {
-    status: number;
-    setIssue(issue: any): void;
-}

package/types/common/exception/http-errors/failed-dependency.error.d.ts

@@ -1,9 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-/**
- * 424 Failed Dependency
- * The request failed due to failure of a previous request.
- */
-export declare class FailedDependencyError extends OpraException {
-    status: number;
-    setIssue(issue: any): void;
-}

package/types/common/exception/http-errors/forbidden.error.d.ts

@@ -1,11 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-/**
- * 403 Forbidden
- * The client does not have access rights to the content; that is, it is unauthorized,
- * so the server is refusing to give the requested resource. Unlike 401 Unauthorized,
- * the client's identity is known to the server.
- */
-export declare class ForbiddenError extends OpraException {
-    status: number;
-    setIssue(issue: any): void;
-}

package/types/common/exception/http-errors/internal-server.error.d.ts

@@ -1,9 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-/**
- * 500 Internal Server Error
- * The server has encountered a situation it does not know how to handle.
- */
-export declare class InternalServerError extends OpraException {
-    status: number;
-    setIssue(issue: any): void;
-}

package/types/common/exception/http-errors/method-not-allowed.error.d.ts

@@ -1,10 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-/**
- * 405 Method Not Allowed
- * The request method is known by the server but is not supported by the target resource.
- * For example, an API may not allow calling DELETE to remove a resource.
- */
-export declare class MethodNotAllowedError extends OpraException {
-    status: number;
-    setIssue(issue: any): void;
-}

package/types/common/exception/http-errors/not-acceptable.error.d.ts

@@ -1,10 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-/**
- * 406 Not Acceptable
- * This response is sent when the web server, after performing server-driven content negotiation,
- * doesn't find any content that conforms to the criteria given by the user agent.
- */
-export declare class NotAcceptableError extends OpraException {
-    status: number;
-    setIssue(issue: any): void;
-}

package/types/common/exception/http-errors/not-found.error.d.ts

@@ -1,13 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-/**
- * 404 Not Found
- * The server can not find the requested resource. In the browser, this means the URL is not recognized.
- * In an API, this can also mean that the endpoint is valid but the resource itself does not exist.
- * Servers may also send this response instead of 403 Forbidden to hide the existence of a resource
- * from an unauthorized client. This response code is probably the most well known due to its
- * frequent occurrence on the web.
- */
-export declare class NotFoundError extends OpraException {
-    status: number;
-    setIssue(issue: any): void;
-}

package/types/common/exception/http-errors/unauthorized.error.d.ts

@@ -1,10 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-/**
- * 401 Unauthorized
- * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated".
- * That is, the client must authenticate itself to get the requested response.
- */
-export declare class UnauthorizedError extends OpraException {
-    status: number;
-    setIssue(issue: any): void;
-}

package/types/common/exception/http-errors/unprocessable-entity.error.d.ts

@@ -1,9 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-/**
- * 422 Unprocessable Entity
- * The request was well-formed but was unable to be followed due to semantic errors.
- */
-export declare class UnprocessableEntityError extends OpraException {
-    status: number;
-    setIssue(issue: any): void;
-}

package/types/common/exception/index.d.ts

@@ -1,15 +0,0 @@
-export * from './opra-exception.js';
-export * from './error-issue.js';
-export * from './wrap-exception.js';
-export * from './enums/issue-severity.enum.js';
-export * from './http-errors/bad-request.error.js';
-export * from './http-errors/failed-dependency.error.js';
-export * from './http-errors/forbidden.error.js';
-export * from './http-errors/internal-server.error.js';
-export * from './http-errors/method-not-allowed.error.js';
-export * from './http-errors/not-acceptable.error.js';
-export * from './http-errors/not-found.error.js';
-export * from './http-errors/unauthorized.error.js';
-export * from './http-errors/unprocessable-entity.error.js';
-export * from './resource-errors/resource-conflict.error.js';
-export * from './resource-errors/resource-not-found.error.js';

package/types/common/exception/opra-exception.d.ts

@@ -1,15 +0,0 @@
-import { ErrorIssue } from './error-issue.js';
-/**
- * Defines the base Opra exception, which is handled by the default Exceptions Handler.
- */
-export declare class OpraException extends Error {
-    protected _issue: ErrorIssue;
-    status: number;
-    cause?: Error;
-    constructor(issue?: string | Partial<ErrorIssue>, cause?: Error);
-    get issue(): ErrorIssue;
-    setIssue(issue: Partial<ErrorIssue>): void;
-    setStatus(status: number): this;
-    protected _initName(): void;
-    protected _init(issue: Error | Partial<ErrorIssue> | string): void;
-}

package/types/common/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/common/exception/resource-errors/resource-not-found.error.d.ts

@@ -1,8 +0,0 @@
-import { OpraException } from '../opra-exception.js';
-/**
- * The server cannot find the requested resource.
- * This can also mean that the endpoint is valid but the resource itself does not exist.
- */
-export declare class ResourceNotFoundError extends OpraException {
-    constructor(resource: string, keyValue?: any, cause?: Error);
-}

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

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