@opra/common 0.33.13 → 1.0.0-alpha.2

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

@@ -1,51 +1,77 @@
 import 'reflect-metadata';
-import { StrictOmit, Type } from 'ts-gems';
-import { ResponsiveMap } from '../../helpers/index.js';
+import { Combine, Type, TypeThunkAsync } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
-import type { TypeThunkAsync } from '../../types.js';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexTypeClass } from './complex-type-class.js';
+import type { DocumentElement } from '../common/document-element.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import { ApiField } from './api-field.js';
+import { ComplexTypeBase } from './complex-type-base.js';
 import { DataType } from './data-type.js';
-import { ApiField } from './field.js';
 import type { MappedType } from './mapped-type.js';
 import type { MixinType } from './mixin-type.js';
 /**
- * Callable class pattern for ComplexType
+ * @namespace ComplexType
+ */
+export declare namespace ComplexType {
+    interface Metadata extends Combine<{
+        kind: OpraSchema.ComplexType.Kind;
+        fields?: Record<string, ApiField.Metadata>;
+        additionalFields?: boolean | string | TypeThunkAsync | ['error'] | ['error', string];
+    }, DataType.Metadata, OpraSchema.ComplexType> {
+    }
+    interface Options extends Combine<Pick<Metadata, 'additionalFields' | 'keyField'>, DataType.Options, Pick<OpraSchema.ComplexType, 'abstract'>> {
+    }
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.ComplexType.Kind;
+        base?: ComplexType | MappedType | MixinType;
+        fields?: Record<string, ApiField.InitArguments | ApiField>;
+        additionalFields?: boolean | DataType | ['error'] | ['error', string];
+    }, DataType.InitArguments, ComplexType.Metadata> {
+    }
+    interface ParsedFieldPath {
+        fieldName: string;
+        dataType: DataType;
+        field?: ApiField;
+        additionalField?: boolean;
+        sign?: '+' | '-';
+    }
+}
+/**
+ * Type definition for MixinType
+ * @class ComplexType
  */
-export interface ComplexTypeConstructor {
-    new (document: ApiDocument, init: ComplexType.InitArguments): ComplexType;
-    (options?: ComplexType.DecoratorOptions): ClassDecorator;
+export interface ComplexTypeStatic {
+    /**
+     * Class constructor of ComplexType
+     *
+     * @param owner
+     * @param args
+     * @param context
+     * @constructor
+     */
+    new (owner: DocumentElement, args?: ComplexType.InitArguments, context?: DocumentInitContext): ComplexType;
+    (options?: ComplexType.Options): ClassDecorator;
     prototype: ComplexType;
+    extend<T extends Type>(typeClass: T, fields: Record<string, ApiField.Options>): T;
 }
+/**
+ * Type definition of ComplexType prototype
+ * @interface ComplexType
+ */
 export interface ComplexType extends ComplexTypeClass {
 }
 /**
- * @class ComplexType
- * @decorator ComplexType
+ * ComplexType constructor
  */
-export declare const ComplexType: ComplexTypeConstructor;
+export declare const ComplexType: ComplexTypeStatic;
 /**
- * @namespace ComplexType
+ *
+ * @class ComplexType
  */
-export declare namespace ComplexType {
-    interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.ComplexType, 'ctor' | 'abstract'> {
-        base?: ComplexType | MappedType | MixinType;
-        fields?: Record<string, ApiField.InitArguments>;
-        additionalFields?: boolean | DataType | 'error';
-        embedded?: boolean;
-    }
-    interface OwnProperties extends DataType.OwnProperties {
-        ctor?: Type;
-        additionalFields?: boolean | DataType | 'error';
-        fields: ResponsiveMap<ApiField>;
-        embedded?: boolean;
-    }
-    interface DecoratorOptions extends DataType.DecoratorOptions, Pick<InitArguments, 'ctor' | 'abstract'> {
-        embedded?: boolean;
-        additionalFields?: boolean | 'error' | string | TypeThunkAsync;
-    }
-    interface Metadata extends StrictOmit<OpraSchema.ComplexType, 'fields'> {
-        name: string;
-        fields?: Record<string, ApiField.Metadata>;
-    }
+declare abstract class ComplexTypeClass extends ComplexTypeBase {
+    readonly kind: OpraSchema.ComplexType.Kind;
+    readonly base?: ComplexType | MappedType | MixinType;
+    readonly ctor?: Type;
+    extendsFrom(baseType: DataType): boolean;
+    toJSON(): OpraSchema.ComplexType;
 }
+export {};

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

@@ -1,57 +1,60 @@
-import { RequiredSome, StrictOmit, Type } from 'ts-gems';
-import { OnFailFunction, Validator } from 'valgen';
+import { StrictOmit } from 'ts-gems';
+import { ValidationOptions, Validator } from 'valgen';
+import { FieldsProjection } from '../../helpers/index.js';
+import type { DataTypeBase } from '../../schema/data-type/data-type.interface.js';
 import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
 import { nodeInspectCustom } from '../utils/inspect.util.js';
-import { ApiField } from './field.js';
 /**
- * @class DataType
- * @abstract
+ * @namespace DataType
  */
-export declare abstract class DataType {
-    readonly document: ApiDocument;
-    readonly kind: OpraSchema.DataType.Kind;
-    readonly name?: string;
-    readonly base?: DataType;
-    readonly own: DataType.OwnProperties;
-    description?: string;
-    isEmbedded?: boolean;
-    protected constructor(document: ApiDocument, init?: DataType.InitArguments);
-    abstract generateCodec(codec: 'decode' | 'encode', options?: DataType.GenerateCodecOptions): Validator;
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.DataType;
-    extendsFrom(type: string | Type | DataType): any;
-    toString(): string;
-    [nodeInspectCustom](): string;
-}
 export declare namespace DataType {
-    interface InitArguments {
+    interface Metadata extends DataTypeBase {
         name?: string;
-        description?: string;
-        example?: string | string[];
     }
-    interface DecoratorOptions extends InitArguments {
+    interface Options extends Partial<StrictOmit<Metadata, 'kind' | 'examples'>> {
+        embedded?: boolean;
     }
-    interface Metadata extends RequiredSome<DecoratorOptions, 'name'> {
-        kind: OpraSchema.DataType.Kind;
+    interface InitArguments extends DataType.Metadata {
     }
-    interface OwnProperties {
-    }
-    type GenerateCodecField = StrictOmit<ApiField.InitArguments, 'type' | 'name'> & {
-        type?: DataType | string;
-    };
-    type OverrideFieldsConfig = GenerateCodecField & {
-        overrideFields?: Record<string, OverrideFieldsConfig>;
-    };
-    interface GenerateCodecOptions {
-        caseSensitive?: boolean;
-        pick?: string[] | readonly string[];
-        omit?: string[] | readonly string[];
-        partial?: boolean;
-        operation?: 'read' | 'write';
-        overwriteFields?: Record<string, OverrideFieldsConfig>;
-        designType?: Type;
-        onFail?: OnFailFunction;
+    interface GenerateCodecOptions extends ValidationOptions {
+        documentElement?: DocumentElement;
+        caseInSensitive?: boolean;
+        partial?: boolean | 'deep';
+        projection?: string[] | FieldsProjection | '*';
     }
 }
+interface DataTypeStatic {
+    new (owner: DocumentElement, args?: DataType.InitArguments, context?: DocumentInitContext): DataType;
+    prototype: DataType;
+}
+/**
+ * Type definition of DataType prototype
+ * @interface DataType
+ */
+export interface DataType extends DataTypeClass {
+}
+/**
+ * DataType constructor
+ */
+export declare const DataType: DataTypeStatic;
+/**
+ *
+ * @class DataType
+ */
+declare abstract class DataTypeClass extends DocumentElement {
+    readonly kind: OpraSchema.DataType.Kind;
+    readonly owner: DocumentElement;
+    readonly name?: string;
+    readonly description?: string;
+    readonly abstract?: boolean;
+    readonly examples?: OpraSchema.DataTypeExample[];
+    abstract generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
+    get embedded(): any;
+    abstract extendsFrom(baseType: DataType): boolean;
+    toJSON(): OpraSchema.DataType;
+    toString(): string;
+    [nodeInspectCustom](): string;
+}
+export {};

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

@@ -1,34 +1,70 @@
 import 'reflect-metadata';
-import { StrictOmit } from 'ts-gems';
+import { Combine } from 'ts-gems';
+import { Validator } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
+import type { DocumentElement } from '../common/document-element.js';
 import { DataType } from './data-type.js';
-import { EnumTypeClass } from './enum-type-class.js';
-export interface EnumTypeConstructor {
-    new (document: ApiDocument, init?: EnumType.InitArguments): EnumType;
-    <T extends EnumType.EnumObject | EnumType.EnumArray>(target: T, options: EnumType.Options<T>): EnumType.Metadata;
-}
-export interface EnumType extends EnumTypeClass {
-}
 /**
- * @class EnumType
+ * @namespace EnumType
  */
-export declare const EnumType: EnumTypeConstructor;
 export declare namespace EnumType {
-    type EnumObject = Record<string, OpraSchema.EnumType.Value>;
+    type EnumObject = Record<string, string | number>;
     type EnumArray = readonly string[];
-    interface Metadata extends StrictOmit<OpraSchema.EnumType, 'base'> {
-        name?: string;
-        base?: EnumObject | string;
-    }
-    interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.EnumType, 'base'> {
-        enumObject?: object;
-        base?: EnumType;
-        values: Record<OpraSchema.EnumType.Value, OpraSchema.EnumType.ValueInfo>;
-    }
-    interface Options<T, Keys extends (string | number | symbol) = T extends readonly any[] ? T[number] : keyof T> extends DataType.DecoratorOptions {
+    interface Metadata extends Combine<{
+        kind: OpraSchema.EnumType.Kind;
+        base?: EnumObject | EnumArray | string;
         name: string;
-        base?: EnumObject;
+    }, DataType.Metadata, OpraSchema.EnumType> {
+    }
+    interface Options<T, Keys extends string | number | symbol = T extends readonly any[] ? T[number] : keyof T> extends Combine<{
+        base?: EnumObject | EnumArray | string;
         meanings?: Record<Keys, string>;
+    }, DataType.Options> {
+    }
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.EnumType.Kind;
+        base?: EnumType;
+        instance?: object;
+    }, DataType.InitArguments, EnumType.Metadata> {
     }
 }
+/**
+ * Mixin type definition of class constructor and helper method for EnumType
+ */
+export interface EnumTypeStatic {
+    /**
+     * Class constructor of EnumType
+     *
+     * @param owner
+     * @param args
+     * @constructor
+     */
+    new (owner: DocumentElement, args?: EnumType.InitArguments): EnumType;
+    <T extends EnumType.EnumObject, B extends EnumType.EnumObject>(enumSource: T, base: B, options: EnumType.Options<T>): B & T;
+    <T extends EnumType.EnumArray, B extends EnumType.EnumArray>(enumSource: T, base: B, options: EnumType.Options<T>): B & T;
+    <T extends EnumType.EnumObject | EnumType.EnumArray>(target: T, options: EnumType.Options<T>): T;
+}
+/**
+ * Type definition of EnumType prototype
+ * @interface EnumType
+ */
+export interface EnumType extends EnumTypeClass {
+}
+/**
+ * @class EnumType
+ */
+export declare const EnumType: EnumTypeStatic;
+/**
+ * @class EnumType
+ */
+declare class EnumTypeClass extends DataType {
+    readonly kind: OpraSchema.EnumType.Kind;
+    readonly base?: EnumType;
+    readonly instance?: object;
+    readonly attributes: Record<string | number, OpraSchema.EnumType.ValueInfo>;
+    readonly ownAttributes: Record<string | number, OpraSchema.EnumType.ValueInfo>;
+    extendsFrom(baseType: DataType): boolean;
+    generateCodec(): Validator;
+    toJSON(): OpraSchema.EnumType;
+}
+export {};

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

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

package/types/document/data-type/extended-types/date-string.type.d.ts

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

package/types/document/data-type/extended-types/date-time-string.type.d.ts

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

package/types/document/data-type/extended-types/date-time.type.d.ts

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

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

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

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

@@ -0,0 +1,16 @@
+import { Validator } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class EmailType {
+    constructor(attributes?: Partial<EmailType>);
+    allowDisplayName?: boolean;
+    requireDisplayName?: boolean;
+    utf8LocalPart?: boolean;
+    ignoreMaxLength?: boolean;
+    allowIpDomain?: boolean;
+    domainSpecificValidation?: boolean;
+    hostBlacklist?: string[];
+    hostWhitelist?: string[];
+    blacklistedChars?: string;
+    protected [DECODER](properties?: Partial<this>): Validator;
+    protected [ENCODER](properties?: Partial<this>): Validator;
+}

package/types/document/data-type/extended-types/field-path.type.d.ts

@@ -0,0 +1,15 @@
+import { Type } from 'ts-gems';
+import { Validator } from 'valgen';
+import { DocumentElement } from '../../common/document-element.js';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class FieldPathType {
+    constructor(attributes?: Partial<FieldPathType>);
+    dataType?: Type | string;
+    allowSigns?: 'first' | 'each';
+    [DECODER](properties: Partial<this>, element: DocumentElement): Validator;
+    [ENCODER](properties: Partial<this>, element: DocumentElement): Validator;
+    toJSON(properties: Partial<FieldPathType>, element: DocumentElement): {
+        dataType: string | import("../../../schema/data-type/complex-type.interface.js").ComplexType;
+        allowSigns: "first" | "each" | undefined;
+    };
+}

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

@@ -0,0 +1,16 @@
+import { Type } from 'ts-gems';
+import { Validator } from 'valgen';
+import { FilterRules } from '../../../filter/filter-rules.js';
+import type { DocumentElement } from '../../common/document-element.js';
+import { DECODER, ENCODER } from '../../constants.js';
+export declare class FilterType {
+    constructor(attributes?: Partial<FilterType>);
+    dataType?: Type | string;
+    rules?: Record<string, FilterRules.Rule>;
+    protected [DECODER](properties: Partial<this>, element: DocumentElement): Validator;
+    protected [ENCODER](): Validator;
+    toJSON(properties: Partial<FilterType>, element: DocumentElement): {
+        dataType: string | import("../../../schema/data-type/complex-type.interface.js").ComplexType;
+        rules: Record<string, FilterRules.Rule> | undefined;
+    };
+}

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

@@ -0,0 +1,13 @@
+export * from './base64.type.js';
+export * from './date.type.js';
+export * from './date-string.type.js';
+export * from './date-time.type.js';
+export * from './date-time-string.type.js';
+export * from './email.type.js';
+export * from './field-path.type.js';
+export * from './filter.type.js';
+export * from './object-id.type.js';
+export * from './operation-result.type.js';
+export * from './time.type.js';
+export * from './url.type.js';
+export * from './uuid.type.js';

package/types/document/data-type/extended-types/object-id.type.d.ts

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

package/types/document/{resource/types → data-type/extended-types}/operation-result.type.d.ts

@@ -1,14 +1,15 @@
-import { DeepPartial } from 'ts-gems';
+import { DeepPartial, Type } from 'ts-gems';
 import { ErrorIssue } from '../../../exception/index.js';
 export declare class OperationResult<TPayload = any> {
     constructor(init?: DeepPartial<OperationResult>);
-    context?: string;
-    contextUrl?: string;
-    type?: string;
-    typeUrl?: string;
     affected?: number;
-    count?: number;
     totalMatches?: number;
+    context?: string;
+    type?: string;
+    message?: string;
     payload?: TPayload;
     errors?: ErrorIssue[];
 }
+export declare namespace OperationResult {
+    function forPayload(type: Type): Type<OperationResult>;
+}

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

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

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

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

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