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

Opra common package

import 'reflect-metadata';
import type { Combine, Type } from 'ts-gems';
import { type 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 { DocumentInitContext } from '../common/document-init-context.js';
import { AttributeDecoratorFactory, SimpleTypeDecoratorFactory } from '../decorators/simple-type.decorator.js';
import { DataType } from './data-type.js';
/**
 * @namespace SimpleType
 */
export declare namespace SimpleType {
    interface Metadata extends Combine<{
        kind: OpraSchema.SimpleType.Kind;
    }, DataType.Metadata, OpraSchema.SimpleType> {
    }
    interface Options extends Combine<Pick<OpraSchema.SimpleType, 'nameMappings'>, DataType.Options> {
    }
    interface InitArguments extends Combine<{
        kind: OpraSchema.SimpleType.Kind;
        base?: SimpleType;
        ctor?: Type;
        properties?: object;
        designType?: boolean;
        generateDecoder?: SimpleType.ValidatorGenerator;
        generateEncoder?: SimpleType.ValidatorGenerator;
    }, DataType.InitArguments, SimpleType.Metadata> {
    }
    interface Attribute extends OpraSchema.Attribute {
    }
    type ValidatorGenerator = (properties: Record<string, any>, args: {
        dataType: SimpleType;
        element: DocumentElement;
        scope?: string;
    }) => 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 nameMappings: Record<string, string>;
    readonly ownAttributes: Record<string, SimpleType.Attribute>;
    readonly ownNameMappings: Record<string, string>;
    protected _generateDecoder?: SimpleType.ValidatorGenerator;
    protected _generateEncoder?: SimpleType.ValidatorGenerator;
    properties?: any;
    extend<T>(properties: Partial<T>): SimpleType & T;
    extendsFrom(baseType: DataType | string | Type | object): boolean;
    generateCodec<T extends Record<string, any> | object = object>(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions | null, properties?: Partial<T>): Validator;
    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.SimpleType;
    protected _locateBase(callback: (base: SimpleType) => boolean): SimpleType | undefined;
}
export {};