@opra/common 0.33.13 → 1.0.0-alpha.1

package/types/document/data-type/extended-types/uuid.type.d.ts

@@ -0,0 +1,8 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class UuidType {
+    constructor(attributes?: Partial<UuidType>);
+    version?: 1 | 2 | 3 | 4 | 5;
+    protected [DECODER](properties?: Partial<this>): Validator;
+    protected [ENCODER](properties?: Partial<this>): Validator;
+}

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

@@ -1,62 +1,73 @@
 import 'reflect-metadata';
-import { Class, StrictOmit, Type } from 'ts-gems';
+import { Combine, Type } from 'ts-gems';
+import type { Field } from '../../schema/data-type/field.interface';
 import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexType } from './complex-type.js';
-import { MappedTypeClass } from './mapped-type-class.js';
+import { DocumentElement } from '../common/document-element.js';
+import type { ComplexType } from './complex-type.js';
+import { ComplexTypeBase } from './complex-type-base.js';
+import type { DataType } from './data-type.js';
+import type { MixinType } from './mixin-type';
 /**
- *
- */
-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'>;
-/**
- *
+ * @namespace MappedType
  */
-export declare function PartialType<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'>;
+export declare namespace MappedType {
+    interface Metadata extends Combine<{
+        kind: OpraSchema.MappedType.Kind;
+        base: Type | string;
+    }, DataType.Metadata, Pick<ComplexType.Metadata, 'additionalFields'>, OpraSchema.MappedType> {
+    }
+    interface Options<T, K = keyof T> {
+        pick?: readonly K[];
+        omit?: readonly K[];
+        partial?: readonly K[] | boolean;
+    }
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.MappedType.Kind;
+        base: ComplexType | MappedType | MixinType;
+        ctor?: Type;
+    }, DataType.InitArguments, MappedType.Metadata> {
+    }
+}
 /**
- * Type definition of MappedType constructor type
- * @type MappedTypeConstructor
+ * Type definition of class constructor for MappedType
  */
-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, PartialKey extends keyof I1>(resource: Class<T, I1, S1>, options: {
-        pickKeys?: readonly PickKey[];
-        omitKeys?: readonly OmitKey[];
-        partialKeys?: readonly PartialKey[];
-    }): Class<T, Omit<Pick<I1, PickKey>, OmitKey>>;
+export interface MappedTypeStatic {
+    /**
+     * Class constructor of MappedType
+     *
+     * @param owner
+     * @param args
+     * @constructor
+     */
+    new (owner: DocumentElement, args: MappedType.InitArguments): MappedType;
     _applyMixin(targetType: Type, sourceType: Type, options: MappedType.Options<any> & {
         isInheritedPredicate: (fieldName: string) => boolean;
     }): void;
+    prototype: MappedType;
 }
-/**
- * @class MappedType
- */
-export declare const MappedType: MappedTypeConstructor;
 /**
  * Type definition of MappedType prototype
- * @type MappedType
+ * @interface MappedType
  */
 export interface MappedType extends MappedTypeClass {
 }
 /**
- * @namespace MappedType
+ * MappedType constructor
  */
-export declare namespace MappedType {
-    interface InitArguments extends ComplexType.InitArguments, Pick<OpraSchema.MappedType, 'pick' | 'omit' | 'partial'> {
-    }
-    interface Metadata extends StrictOmit<ComplexType.Metadata, 'kind' | 'base' | 'name'>, Pick<OpraSchema.MappedType, 'pick' | 'omit' | 'partial'> {
-        kind: OpraSchema.MappedType.Kind;
-        base: Type;
-    }
-    interface OwnProperties extends ComplexType.OwnProperties, Pick<OpraSchema.MappedType, 'pick' | 'omit' | 'partial'> {
-    }
-    interface Options<T, K = keyof T> {
-        pick?: readonly K[];
-        omit?: readonly K[];
-        partial?: readonly K[] | boolean;
-    }
+export declare const MappedType: MappedTypeStatic;
+/**
+ *
+ * @class MappedType
+ */
+declare class MappedTypeClass extends ComplexTypeBase {
+    readonly kind: OpraSchema.MappedType.Kind;
+    readonly base: ComplexType | MappedType | MixinType;
+    readonly ctor?: Type;
+    readonly omit?: Field.Name[];
+    readonly pick?: Field.Name[];
+    readonly partial?: Field.Name[] | boolean;
+    readonly required?: Field.Name[] | boolean;
+    extendsFrom(baseType: DataType): boolean;
+    toJSON(): OpraSchema.MappedType;
 }
+export {};

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

@@ -1,43 +1,82 @@
 import 'reflect-metadata';
-import { Class, StrictOmit, Type } from 'ts-gems';
+import { Class, Combine, Type } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexType } from './complex-type.js';
-import { MappedType } from './mapped-type.js';
-import { MixinTypeClass } from './mixin-type-class.js';
+import type { DocumentElement } from '../common/document-element.js';
+import type { ComplexType } from './complex-type.js';
+import { ComplexTypeBase } from './complex-type-base.js';
+import type { DataType } from './data-type.js';
+import type { MappedType } from './mapped-type.js';
 /**
- * Type definition of MixinType constructor type
- * @type MixinTypeConstructor
+ * @namespace MixinType
  */
-export interface MixinTypeConstructor {
+export declare namespace MixinType {
+    interface Metadata extends Combine<{
+        kind: OpraSchema.MixinType.Kind;
+        name?: string;
+        types: Type[];
+    }, DataType.Metadata, Pick<ComplexType.Metadata, 'additionalFields'>, OpraSchema.MixinType> {
+    }
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.MixinType.Kind;
+        types: (ComplexType | MappedType | MixinType)[];
+        ctor?: Type;
+    }, DataType.InitArguments, MixinType.Metadata> {
+    }
+}
+/**
+ * Type definition for MixinType
+ * @class MixinType
+ */
+export interface MixinTypeStatic {
+    /**
+     * Class constructor of MixinType
+     *
+     * @param owner
+     * @param args
+     * @constructor
+     */
+    new (owner: DocumentElement, args: MixinType.InitArguments): MixinType;
+    /**
+     * Create a new mixin type from given two types
+     * @param c1
+     * @param c2
+     * @param options
+     */ <A1 extends any[], I1, S1, A2 extends any[], I2, S2>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, options?: DataType.Options): Class<any[], I1 & I2, S1 & S2>;
+    /**
+     * Helper method that mixes given types
+     * @param c1
+     * @param c2
+     * @param c3
+     * @param options
+     */ <A1 extends any[], I1, S1, A2 extends any[], I2, S2, A3 extends any[], I3, S3>(c1: Class<A1, I1, S1>, c2: Class<A2, I2, S2>, c3?: Class<A3, I3, S3>, options?: DataType.Options): Class<any[], I1 & I2 & I3, S1 & S2 & S3>;
+    /**
+     * Helper method that mixes given types
+     * @param c1
+     * @param c2
+     * @param c3
+     * @param c4
+     * @param options
+     */ <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>, options?: DataType.Options): Class<any[], I1 & I2 & I3 & I4, S1 & S2 & S3 & S4>;
     prototype: MixinType;
-    new (document: ApiDocument, init: MixinType.InitArguments): MixinType;
-    <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;
 }
 /**
  * Type definition of MixinType prototype
- * @type MixinType
+ * @interface
  */
 export interface MixinType extends MixinTypeClass {
 }
 /**
  * @class MixinType
  */
-export declare const MixinType: MixinTypeConstructor;
+export declare const MixinType: MixinTypeStatic;
 /**
- * @namespace MixinType
+ *
+ * @class MixinType
  */
-export declare namespace MixinType {
-    interface InitArguments extends ComplexType.InitArguments {
-        types: (ComplexType | MixinType | MappedType)[];
-    }
-    interface Metadata extends StrictOmit<ComplexType.Metadata, 'kind' | 'base' | 'name'> {
-        kind: OpraSchema.MixinType.Kind;
-        base?: Type;
-        types: Type[];
-    }
-    interface OwnProperties extends ComplexType.OwnProperties {
-        types: (ComplexType | MixinType | MappedType)[];
-    }
+declare class MixinTypeClass extends ComplexTypeBase {
+    readonly kind: OpraSchema.MixinType.Kind;
+    readonly types: (ComplexType | MixinType | MappedType)[];
+    extendsFrom(baseType: DataType): boolean;
+    toJSON(): OpraSchema.MixinType;
 }
+export {};

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

@@ -0,0 +1,15 @@
+import { Class, Type } from 'ts-gems';
+import type { DataType } from './data-type.js';
+/**
+ * Create a new MappedType that omits given fields from base type
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function OmitType(baseType: string | Type, keys: string[], options?: DataType.Options): Type;
+/**
+ * Create a new MappedType that omits given fields from base type
+ * @param baseType
+ * @param keys
+ * @param options
+ */ export declare function OmitType<Args extends any[], Instance, Static, K extends keyof Instance>(baseType: Class<Args, Instance, Static>, keys: readonly K[], options?: DataType.Options): Class<Args, Omit<Instance, K>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;

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

@@ -0,0 +1,28 @@
+import { Class, PartialSome, Type } from 'ts-gems';
+import type { DataType } from './data-type.js';
+/**
+ * Create a new MappedType that marks given or all fields as optional
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function PartialType(baseType: string | Type, keys: string[], options?: DataType.Options): Type;
+/**
+ * Create a new MappedType that marks given or all fields as optional
+ * @param baseType
+ * @param options
+ */
+export declare function PartialType(baseType: string | Type, options?: DataType.Options): Type;
+/**
+ * Create a new MappedType that marks given fields as optional
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function PartialType<Args extends any[], Instance, Static, K extends keyof Instance>(baseType: Class<Args, Instance, Static>, keys: readonly K[], options?: DataType.Options): Class<Args, PartialSome<Instance, K>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;
+/**
+ * Create a new MappedType that marks all fields as optional
+ * @param baseType
+ * @param options
+ */
+export declare function PartialType<Args extends any[], Instance, Static>(baseType: Class<Args, Instance, Static>, options?: DataType.Options): Class<Args, Partial<Instance>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;

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

@@ -0,0 +1,16 @@
+import { Class, Type } from 'ts-gems';
+import type { DataType } from './data-type.js';
+/**
+ * Create a new MappedType that picks given fields from base type
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function PickType(baseType: string | Type, keys: string[], options?: DataType.Options): Type;
+/**
+ * Create a new MappedType that picks given fields from base type
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function PickType<Args extends any[], Instance, Static, K extends keyof Instance>(baseType: Class<Args, Instance, Static>, keys: readonly K[], options?: DataType.Options): Class<Args, Pick<Instance, K>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;

package/types/document/data-type/primitive-types/any.type.d.ts

@@ -0,0 +1,7 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class AnyType {
+    constructor(properties?: Partial<AnyType>);
+    protected [DECODER](): Validator;
+    protected [ENCODER](): Validator;
+}

package/types/document/data-type/primitive-types/bigint.type.d.ts

@@ -0,0 +1,8 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { NumberType } from './number.type.js';
+export declare class BigintType extends NumberType {
+    constructor(attributes?: Partial<BigintType>);
+    protected [DECODER](properties: Partial<this>): Validator;
+    protected [ENCODER](properties: Partial<this>): Validator;
+}

package/types/document/data-type/primitive-types/boolean.type.d.ts

@@ -0,0 +1,7 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class BooleanType {
+    constructor(properties?: Partial<BooleanType>);
+    protected [DECODER](): Validator;
+    protected [ENCODER](): Validator;
+}

package/types/document/data-type/primitive-types/index.d.ts

@@ -0,0 +1,8 @@
+export * from './any.type.js';
+export * from './bigint.type.js';
+export * from './boolean.type.js';
+export * from './integer.type.js';
+export * from './null.type.js';
+export * from './number.type.js';
+export * from './object.type.js';
+export * from './string.type.js';

package/types/document/data-type/primitive-types/integer.type.d.ts

@@ -0,0 +1,8 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { NumberType } from './number.type.js';
+export declare class IntegerType extends NumberType {
+    constructor(properties?: Partial<IntegerType>);
+    protected [DECODER](properties: Partial<this>): Validator;
+    protected [ENCODER](properties: Partial<this>): Validator;
+}

package/types/document/data-type/primitive-types/null.type.d.ts

@@ -0,0 +1,7 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class NullType {
+    constructor(properties?: Partial<NullType>);
+    protected [DECODER](): Validator;
+    protected [ENCODER](): Validator;
+}

package/types/document/data-type/primitive-types/number.type.d.ts

@@ -0,0 +1,9 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class NumberType {
+    constructor(properties?: Partial<NumberType>);
+    minValue?: number;
+    maxValue?: number;
+    protected [DECODER](properties: Partial<this>): Validator;
+    protected [ENCODER](properties: Partial<this>): Validator;
+}

package/types/document/data-type/primitive-types/object.type.d.ts

@@ -0,0 +1,3 @@
+export declare class ObjectType {
+    constructor(properties?: Partial<ObjectType>);
+}

package/types/document/data-type/primitive-types/string.type.d.ts

@@ -0,0 +1,11 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class StringType {
+    constructor(properties?: Partial<StringType>);
+    pattern?: string | RegExp;
+    patternName?: string;
+    minLength?: number;
+    maxLength?: number;
+    protected [DECODER](properties: Partial<this>): Validator;
+    protected [ENCODER](properties: Partial<this>): Validator;
+}

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

@@ -0,0 +1,22 @@
+import { Class, RequiredSome, Type } from 'ts-gems';
+import type { DataType } from './data-type.js';
+/**
+ * Create a new MappedType that marks given or all fields as required
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function RequiredType(baseType: string | Type, keys?: string[] | true, options?: DataType.Options): Type;
+/**
+ * Create a new MappedType that marks given fields as baseType
+ * @param baseType
+ * @param keys
+ * @param options
+ */
+export declare function RequiredType<Args extends any[], Instance, Static, K extends keyof Instance>(baseType: Class<Args, Instance, Static>, keys?: readonly K[], options?: DataType.Options): Class<Args, RequiredSome<Instance, K>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;
+/**
+ * Create a new MappedType that marks all fields as baseType
+ * @param baseType
+ * @param options
+ */
+export declare function RequiredType<Args extends any[], Instance, Static>(baseType: Class<Args, Instance, Static>, options?: DataType.Options): Class<Args, Required<Instance>> & Omit<Pick<Static, keyof typeof baseType>, 'prototype' | 'constructor'>;

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

@@ -1,36 +1,75 @@
 import 'reflect-metadata';
+import { Combine, Type } from 'ts-gems';
 import { Validator } from 'valgen';
-import type { ApiDocument } from '../api-document.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { DocumentElement } from '../common/document-element';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import { AttributeDecoratorFactory, SimpleTypeDecoratorFactory } from '../decorators/simple-type.decorator.js';
 import { DataType } from './data-type.js';
-import { SimpleTypeClass } from './simple-type-class.js';
-export interface SimpleTypeConstructor {
-    new (document: ApiDocument, init: SimpleType.InitArguments): SimpleType;
-    (options?: SimpleType.DecoratorOptions): (target: any) => any;
-    prototype: SimpleType;
-}
-export interface SimpleType extends SimpleTypeClass {
-}
-/**
- * @class SimpleType
- */
-export declare const SimpleType: SimpleTypeConstructor;
 /**
  * @namespace SimpleType
  */
 export declare namespace SimpleType {
-    interface InitArguments extends DataType.InitArguments {
-        base?: SimpleType;
-        decoder?: Validator;
-        encoder?: Validator;
+    interface Metadata extends Combine<{
+        kind: OpraSchema.SimpleType.Kind;
+    }, DataType.Metadata, OpraSchema.SimpleType> {
     }
-    interface DecoratorOptions extends DataType.DecoratorOptions {
-        decoder?: Validator;
-        encoder?: Validator;
+    interface Options extends DataType.Options {
     }
-    interface Metadata extends DataType.Metadata {
-        decoder?: Validator;
-        encoder?: Validator;
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.SimpleType.Kind;
+        base?: SimpleType;
+        ctor?: Type;
+        properties?: object;
+        generateDecoder?: SimpleType.ValidatorGenerator;
+        generateEncoder?: SimpleType.ValidatorGenerator;
+    }, DataType.InitArguments, SimpleType.Metadata> {
     }
-    interface OwnProperties extends DataType.OwnProperties {
+    interface Attribute extends OpraSchema.Attribute {
     }
+    type ValidatorGenerator = (properties: Record<string, any>, element: DocumentElement) => Validator;
+}
+/**
+ * Type definition for MixinType
+ * @class SimpleType
+ */
+export interface SimpleTypeStatic extends SimpleTypeDecoratorFactory {
+    /**
+     * Class constructor of SimpleType
+     *
+     * @param owner
+     * @param initArgs
+     * @param context
+     * @constructor
+     */
+    new (owner: DocumentElement, initArgs: SimpleType.InitArguments, context?: DocumentInitContext): SimpleType;
+    prototype: SimpleType;
+    Attribute: AttributeDecoratorFactory;
+}
+/**
+ * Type definition of SimpleType prototype
+ * @interface SimpleType
+ */
+export interface SimpleType extends SimpleTypeClass {
+}
+/**
+ * SimpleType constructor
+ */
+export declare const SimpleType: SimpleTypeStatic;
+/**
+ *
+ * @class SimpleType
+ */
+declare abstract class SimpleTypeClass extends DataType {
+    readonly kind: OpraSchema.SimpleType.Kind;
+    readonly base?: SimpleType;
+    readonly attributes: Record<string, SimpleType.Attribute>;
+    readonly ownAttributes: Record<string, SimpleType.Attribute>;
+    protected _generateDecoder?: SimpleType.ValidatorGenerator;
+    protected _generateEncoder?: SimpleType.ValidatorGenerator;
+    properties?: any;
+    extendsFrom(baseType: DataType): boolean;
+    generateCodec<T extends Record<string, any> | object = object>(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions | null, properties?: Partial<T>): Validator;
+    toJSON(): OpraSchema.SimpleType;
 }
+export {};

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

@@ -0,0 +1,3 @@
+import { Type } from 'ts-gems';
+import type { DataType } from '../data-type';
+export declare function createMappedClass(source: string | Type, config: any, options?: DataType.Options): any;

package/types/document/data-type/utils/get-is-inherited-predicate-fn.d.ts

@@ -0,0 +1 @@
+export declare function getIsInheritedPredicateFn(pick?: string[], omit?: string[]): (propertyName: string) => boolean;

package/types/document/decorators/api-field-decorator.d.ts

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

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

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

package/types/document/decorators/http-controller.decorator.d.ts

@@ -0,0 +1,14 @@
+import { StrictOmit, Type, TypeThunkAsync } from 'ts-gems';
+import type { HttpController } from '../http/http-controller';
+import type { HttpParameter } from '../http/http-parameter';
+export interface HttpControllerDecorator<T extends HttpControllerDecorator<any> = HttpControllerDecorator<any>> extends ClassDecorator {
+    Cookie(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | Type | false): T;
+    Header(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync | false): T;
+    QueryParam(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync | false): T;
+    PathParam(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync | false): T;
+    UseType(...type: TypeThunkAsync[]): T;
+}
+export interface HttpControllerDecoratorFactory {
+    <T extends HttpController.Options>(options?: T): HttpControllerDecorator;
+}
+export declare function HttpControllerDecoratorFactory<O extends HttpController.Options>(options?: O): HttpControllerDecorator;

package/types/document/decorators/http-operation-entity.decorator.d.ts

@@ -0,0 +1,100 @@
+import { StrictOmit, Type, TypeThunkAsync } from 'ts-gems';
+import { OpraFilter } from '../../filter/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { HttpParameter } from '../http/http-parameter.js';
+import { HttpRequestBody } from '../http/http-request-body.js';
+import { HttpOperationDecorator } from './http-operation.decorator.js';
+/** Augmentation **/
+declare module '../http/http-operation' {
+    /**
+     * HttpOperationConstructor
+     */
+    interface HttpOperationStatic {
+        Entity: HttpOperationEntity;
+    }
+    interface HttpOperationEntity {
+        Create(type: Type | string, options?: StrictOmit<HttpOperation.Entity.CreateArgs, 'type'>): HttpOperation.Entity.CreateDecorator;
+        Create(args: HttpOperation.Entity.CreateArgs): HttpOperation.Entity.CreateDecorator;
+        Delete(type: Type | string, options?: StrictOmit<HttpOperation.Entity.DeleteArgs, 'type'>): HttpOperation.Entity.DeleteDecorator;
+        Delete(args: HttpOperation.Entity.DeleteArgs): HttpOperation.Entity.DeleteDecorator;
+        DeleteMany(type: Type | string, options?: StrictOmit<HttpOperation.Entity.DeleteManyArgs, 'type'>): HttpOperation.Entity.DeleteManyDecorator;
+        DeleteMany(args: HttpOperation.Entity.DeleteManyArgs): HttpOperation.Entity.DeleteManyDecorator;
+        FindMany(type: Type | string, options?: StrictOmit<HttpOperation.Entity.FindManyArgs, 'type'>): HttpOperation.Entity.FindManyDecorator;
+        FindMany(args: HttpOperation.Entity.FindManyArgs): HttpOperation.Entity.FindManyDecorator;
+        Get(type: Type | string, options?: StrictOmit<HttpOperation.Entity.GetArgs, 'type'>): HttpOperation.Entity.GetDecorator;
+        Get(args: HttpOperation.Entity.GetArgs): HttpOperation.Entity.GetDecorator;
+        Update(type: Type | string, options?: StrictOmit<HttpOperation.Entity.UpdateArgs, 'type'>): HttpOperation.Entity.UpdateDecorator;
+        Update(args: HttpOperation.Entity.UpdateArgs): HttpOperation.Entity.UpdateDecorator;
+        UpdateMany(type: Type | string, options?: StrictOmit<HttpOperation.Entity.UpdateManyArgs, 'type'>): HttpOperation.Entity.UpdateManyDecorator;
+        UpdateMany(args: HttpOperation.Entity.UpdateManyArgs): HttpOperation.Entity.UpdateManyDecorator;
+    }
+    namespace HttpOperation {
+        namespace Entity {
+            /** Create */
+            interface CreateDecorator extends HttpOperationDecorator {
+            }
+            interface CreateArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+                requestBody?: Pick<HttpRequestBody.Options, 'description' | 'maxContentSize'> & {
+                    type?: Type | string;
+                    immediateFetch?: boolean;
+                };
+            }
+            /** Delete */
+            interface DeleteDecorator extends HttpOperationDecorator {
+                KeyParam(name: string, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+            }
+            interface DeleteArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+            }
+            /** DeleteMany */
+            interface DeleteManyDecorator extends HttpOperationDecorator {
+                Filter(field: OpraSchema.Field.QualifiedName, operators?: OpraFilter.ComparisonOperator[] | string, notes?: string): this;
+            }
+            interface DeleteManyArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+            }
+            /** FindMany */
+            interface FindManyDecorator extends HttpOperationDecorator {
+                SortFields(...fields: OpraSchema.Field.QualifiedName[]): FindManyDecorator;
+                DefaultSort(...fields: OpraSchema.Field.QualifiedName[]): FindManyDecorator;
+                Filter(field: OpraSchema.Field.QualifiedName, operators?: OpraFilter.ComparisonOperator[] | string, notes?: string): this;
+            }
+            interface FindManyArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+                defaultLimit?: number;
+                maxLimit?: number;
+            }
+            /** Get */
+            interface GetDecorator extends HttpOperationDecorator {
+                KeyParam(name: string, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+            }
+            interface GetArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+            }
+            /** Update */
+            interface UpdateDecorator extends HttpOperationDecorator {
+                KeyParam(name: string, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+                Filter(field: OpraSchema.Field.QualifiedName, operators?: OpraFilter.ComparisonOperator[] | string, notes?: string): this;
+            }
+            interface UpdateArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+                requestBody?: Pick<HttpRequestBody.Options, 'description' | 'maxContentSize'> & {
+                    type?: Type | string;
+                    immediateFetch?: boolean;
+                };
+            }
+            /** UpdateMany */
+            interface UpdateManyDecorator extends HttpOperationDecorator {
+                Filter(field: OpraSchema.Field.QualifiedName, operators?: OpraFilter.ComparisonOperator[] | string, notes?: string): this;
+            }
+            interface UpdateManyArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+                requestBody?: Pick<HttpRequestBody.Options, 'description' | 'maxContentSize'> & {
+                    type?: Type | string;
+                    immediateFetch?: boolean;
+                };
+            }
+        }
+    }
+}