@opra/common/document/data-type/data-type.d.ts

Opra common package

import { type StrictOmit, type Type } from 'ts-gems';
import type { 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 type { ApiField } from './api-field.js';
/**
 * @namespace DataType
 */
export declare namespace DataType {
    interface Metadata extends DataTypeBase {
        name?: string;
        scopePattern?: (string | RegExp) | (string | RegExp)[];
    }
    interface Options extends Partial<StrictOmit<Metadata, 'kind' | 'examples'>> {
        embedded?: boolean;
    }
    interface InitArguments extends DataType.Metadata {
    }
    interface GenerateCodecOptions extends ValidationOptions {
        documentElement?: DocumentElement;
        scope?: string;
        caseInSensitive?: boolean;
        partial?: boolean | 'deep';
        projection?: string[] | FieldsProjection | '*';
        keepKeyFields?: boolean;
        ignoreReadonlyFields?: boolean;
        ignoreWriteonlyFields?: boolean;
        allowPatchOperators?: boolean;
        fieldHook?: (field: ApiField, currentPath: string, defaultGenerator: () => Validator) => Validator;
    }
}
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 scopePattern?: (string | RegExp)[];
    readonly name?: string;
    readonly description?: string;
    readonly abstract?: boolean;
    readonly examples?: OpraSchema.DataTypeExample[];
    abstract generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions, properties?: any): Validator;
    get embedded(): any;
    abstract extendsFrom(baseType: DataType | string | Type | object): boolean;
    inScope(scope?: string | '*'): boolean;
    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.DataType;
    toString(): string;
    protected abstract _locateBase(callback: (base: DataType) => boolean): DataType | undefined;
    [nodeInspectCustom](): string;
}
export {};