@opra/core 0.0.5

package/esm/exception/index.d.ts

@@ -0,0 +1,8 @@
+export * from './api-exception.js';
+export * from './errors/bad-request.error.js';
+export * from './errors/failed-dependency.error.js';
+export * from './errors/internal-server.error.js';
+export * from './errors/method-not-allowed.error.js';
+export * from './errors/not-found.error.js';
+export * from './errors/unauthorized.error.js';
+export * from './errors/unprocessable-entity.error.js';

package/esm/exception/index.js

@@ -0,0 +1,8 @@
+export * from './api-exception.js';
+export * from './errors/bad-request.error.js';
+export * from './errors/failed-dependency.error.js';
+export * from './errors/internal-server.error.js';
+export * from './errors/method-not-allowed.error.js';
+export * from './errors/not-found.error.js';
+export * from './errors/unauthorized.error.js';
+export * from './errors/unprocessable-entity.error.js';

package/esm/implementation/adapter/adapter.d.ts

@@ -0,0 +1,18 @@
+import { I18n } from '@opra/i18n';
+import { ApiException } from '../../exception/index.js';
+import { ExecutionContext } from '../execution-context.js';
+import { OpraService } from '../opra-service.js';
+export declare namespace OpraAdapter {
+    interface Options {
+        i18n?: I18n;
+    }
+}
+export declare abstract class OpraAdapter<TAdapterContext = any, TOptions extends OpraAdapter.Options = OpraAdapter.Options> {
+    readonly service: OpraService;
+    i18n: I18n;
+    constructor(service: OpraService, options?: TOptions);
+    protected abstract prepareExecutionContexts(adapterContext: TAdapterContext, userContext: any): ExecutionContext[];
+    protected abstract sendResponse(adapterContext: TAdapterContext, executionContexts: ExecutionContext[]): Promise<void>;
+    protected abstract sendError(adapterContext: TAdapterContext, error: ApiException): Promise<void>;
+    protected handler(adapterContext: TAdapterContext, userContext: any): Promise<void>;
+}

package/esm/implementation/adapter/adapter.js

@@ -0,0 +1,68 @@
+import { isPromise } from 'util/types';
+import { I18n } from '@opra/i18n';
+import { ApiException, FailedDependencyError, InternalServerError } from '../../exception/index.js';
+export class OpraAdapter {
+    service;
+    i18n;
+    constructor(service, options) {
+        this.service = service;
+        this.i18n = options?.i18n || I18n.defaultInstance;
+    }
+    async handler(adapterContext, userContext) {
+        let executionContexts;
+        try {
+            executionContexts = this.prepareExecutionContexts(adapterContext, userContext);
+        }
+        catch (e) {
+            const error = InternalServerError.wrap(e);
+            await this.sendError(adapterContext, error);
+            return;
+        }
+        let stop = false;
+        // Read requests can be executed simultaneously, write request should be executed one by one
+        let promises;
+        let exclusive = false;
+        for (const ctx of executionContexts) {
+            const request = ctx.request;
+            const response = ctx.response;
+            exclusive = exclusive || request.query.operationType !== 'read';
+            try {
+                // Wait previous read requests before executing update request
+                if (exclusive && promises) {
+                    await Promise.all(promises);
+                    promises = undefined;
+                }
+                // If previous request in bucket had an error and executed an update
+                // we do not execute next requests
+                if (stop) {
+                    response.errors.push(new FailedDependencyError());
+                }
+                else {
+                    const resource = ctx.request.query.resource;
+                    const v = resource.execute(ctx);
+                    if (isPromise(v)) {
+                        if (exclusive)
+                            await v;
+                        else {
+                            promises = promises || [];
+                            promises.push(v);
+                        }
+                    }
+                    // todo execute sub property queries
+                }
+            }
+            catch (e) {
+                response.errors.unshift(ApiException.wrap(e));
+            }
+            if (response.errors && response.errors.length) {
+                // noinspection SuspiciousTypeOfGuard
+                response.errors = response.errors.map(e => ApiException.wrap(e));
+                if (exclusive)
+                    stop = stop || !!response.errors.find(e => !(e.response.severity === 'warning' || e.response.severity === 'info'));
+            }
+        }
+        if (promises)
+            await Promise.all(promises);
+        await this.sendResponse(adapterContext, executionContexts);
+    }
+}

package/esm/implementation/adapter/express-adapter.d.ts

@@ -0,0 +1,12 @@
+import type { Application, Request } from 'express';
+import type { IHttpAdapterContext } from '../../interfaces/http-context.interface.js';
+import type { OpraService } from '../opra-service.js';
+import { OpraHttpAdapter } from './http-adapter.js';
+export declare namespace OpraExpressAdapter {
+    interface Options extends OpraHttpAdapter.Options {
+        userContext?: (request: Request) => object | Promise<object>;
+    }
+}
+export declare class OpraExpressAdapter extends OpraHttpAdapter<IHttpAdapterContext, OpraExpressAdapter.Options> {
+    static init(app: Application, service: OpraService, options?: OpraExpressAdapter.Options): OpraExpressAdapter;
+}

package/esm/implementation/adapter/express-adapter.js

@@ -0,0 +1,89 @@
+import { normalizePath } from '@opra/url';
+import { OpraHttpAdapter } from './http-adapter.js';
+export class OpraExpressAdapter extends OpraHttpAdapter {
+    static init(app, service, options) {
+        const adapter = new OpraExpressAdapter(service, options);
+        const prefix = '/' + normalizePath(options?.prefix, true);
+        const userContextResolver = options?.userContext;
+        app.use(prefix, (request, response, next) => {
+            (async () => {
+                const userContext = userContextResolver && await userContextResolver(request);
+                const req = new ExpressRequestWrapper(request);
+                const res = new ExpressResponseWrapper(response);
+                const adapterContext = {
+                    getRequest: () => req,
+                    getResponse: () => res
+                };
+                await adapter.handler(adapterContext, userContext);
+            })().catch(e => next(e));
+        });
+        return adapter;
+    }
+}
+class ExpressRequestWrapper {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    getInstance() {
+        return this.instance;
+    }
+    getMethod() {
+        return this.instance.method;
+    }
+    getUrl() {
+        return this.instance.url;
+    }
+    getHeaderNames() {
+        return Object.keys(this.instance.headers);
+    }
+    getHeader(name) {
+        return this.instance.get(name);
+    }
+    getHeaders() {
+        return this.instance.headers;
+    }
+    getBody() {
+        return this.instance.body;
+    }
+}
+class ExpressResponseWrapper {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    getInstance() {
+        return this.instance;
+    }
+    getHeaderNames() {
+        return this.instance.getHeaderNames();
+    }
+    getHeader(name) {
+        return this.instance.get(name);
+    }
+    setHeader(name, value) {
+        this.instance.setHeader(name, value);
+        return this;
+    }
+    getStatus() {
+        return this.instance.statusCode;
+    }
+    setStatus(value) {
+        // noinspection SuspiciousTypeOfGuard
+        this.instance.status(typeof value === 'number'
+            ? value
+            : parseInt(value, 10) || 500);
+        return this;
+    }
+    send(body) {
+        if (typeof body === 'string' || Buffer.isBuffer(body))
+            this.instance.send(body);
+        else
+            this.instance.json(body);
+        return this;
+    }
+    end() {
+        this.instance.end();
+        return this;
+    }
+}

package/esm/implementation/adapter/http-adapter.d.ts

@@ -0,0 +1,27 @@
+import { OpraURL } from '@opra/url';
+import { ApiException } from '../../exception/index.js';
+import { ExecutionQuery } from '../../interfaces/execution-query.interface.js';
+import { IHttpAdapterContext } from '../../interfaces/http-context.interface.js';
+import { HeadersObject } from '../../utils/headers.js';
+import { ExecutionContext } from '../execution-context.js';
+import { OpraAdapter } from './adapter.js';
+export declare namespace OpraHttpAdapter {
+    type Options = OpraAdapter.Options & {
+        prefix?: string;
+    };
+}
+interface PreparedOutput {
+    status: number;
+    headers?: Record<string, string>;
+    body?: any;
+}
+export declare class OpraHttpAdapter<TAdapterContext extends IHttpAdapterContext, TOptions extends OpraHttpAdapter.Options = OpraHttpAdapter.Options> extends OpraAdapter<IHttpAdapterContext, TOptions> {
+    protected prepareExecutionContexts(adapterContext: TAdapterContext, userContext: any): ExecutionContext[];
+    prepareExecutionContext(adapterContext: any, url: OpraURL, method: string, headers: HeadersObject, body?: any, userContext?: any): ExecutionContext;
+    buildQuery(url: OpraURL, method: string, body?: any): ExecutionQuery | undefined;
+    protected sendResponse(adapterContext: TAdapterContext, executionContexts: ExecutionContext[]): Promise<void>;
+    protected isBatch(adapterContext: any): boolean;
+    protected createOutput(ctx: ExecutionContext): PreparedOutput;
+    protected sendError(adapterContext: TAdapterContext, error: ApiException): Promise<void>;
+}
+export {};

package/esm/implementation/adapter/http-adapter.js

@@ -0,0 +1,258 @@
+import { OpraURL } from '@opra/url';
+import { OpraVersion } from '../../constants.js';
+import { HttpHeaders, HttpStatus } from '../../enums/index.js';
+import { ApiException, BadRequestError, InternalServerError, MethodNotAllowedError, NotFoundError, } from '../../exception/index.js';
+import { ExecutionQuery } from '../../interfaces/execution-query.interface.js';
+import { Headers } from '../../utils/headers.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import { ExecutionContext, ExecutionRequest, ExecutionResponse } from '../execution-context.js';
+import { ContainerResourceController } from '../resource/container-resource-controller.js';
+import { EntityResourceInfo } from '../resource/entity-resource-info.js';
+import { OpraAdapter } from './adapter.js';
+export class OpraHttpAdapter extends OpraAdapter {
+    prepareExecutionContexts(adapterContext, userContext) {
+        const req = adapterContext.getRequest();
+        // todo implement batch requests
+        if (this.isBatch(adapterContext)) {
+            throw new Error('not implemented yet');
+        }
+        const url = new OpraURL(req.getUrl());
+        return [this.prepareExecutionContext(adapterContext, url, req.getMethod(), Headers.from(req.getHeaders()), req.getBody(), userContext)];
+    }
+    prepareExecutionContext(adapterContext, url, method, headers, body, userContext) {
+        if (!url.path.size)
+            throw new BadRequestError();
+        if (method !== 'GET' && url.path.size > 1)
+            throw new BadRequestError();
+        const query = this.buildQuery(url, method, body);
+        if (!query)
+            throw new MethodNotAllowedError({
+                message: `Method "${method}" is not allowed by target resource`
+            });
+        const request = new ExecutionRequest({
+            query,
+            headers,
+            params: url.searchParams,
+        });
+        const response = new ExecutionResponse();
+        // noinspection UnnecessaryLocalVariableJS
+        const executionContext = new ExecutionContext({
+            type: 'http',
+            service: this.service,
+            request,
+            response,
+            adapterContext,
+            userContext,
+            continueOnError: request.query.operationType === 'read'
+        });
+        return executionContext;
+    }
+    buildQuery(url, method, body) {
+        let container = this.service;
+        try {
+            let pathIndex = 0;
+            const pathLen = url.path.size;
+            while (pathIndex < pathLen) {
+                let p = url.path.get(pathIndex++);
+                const resource = container.getResource(p.resource);
+                // Move through path directories (containers)
+                if (resource instanceof ContainerResourceController) {
+                    container = resource;
+                }
+                else {
+                    method = method.toUpperCase();
+                    if (resource instanceof EntityResourceInfo) {
+                        const scope = p.key ? 'instance' : 'collection';
+                        if (pathIndex < pathLen && !(method === 'GET' && scope === 'instance'))
+                            return;
+                        let query;
+                        switch (method) {
+                            case 'GET': {
+                                if (scope === 'collection') {
+                                    query = ExecutionQuery.forSearch(resource, {
+                                        filter: url.searchParams.get('$filter'),
+                                        limit: url.searchParams.get('$limit'),
+                                        skip: url.searchParams.get('$skip'),
+                                        distinct: url.searchParams.get('$distinct'),
+                                        total: url.searchParams.get('$total'),
+                                        sort: url.searchParams.get('$sort'),
+                                        pick: url.searchParams.get('$pick'),
+                                        omit: url.searchParams.get('$omit'),
+                                        include: url.searchParams.get('$include'),
+                                    });
+                                }
+                                else {
+                                    query = ExecutionQuery.forRead(resource, p.key, {
+                                        pick: url.searchParams.get('$pick'),
+                                        omit: url.searchParams.get('$omit'),
+                                        include: url.searchParams.get('$include')
+                                    });
+                                    // Move through properties
+                                    let nested;
+                                    let path = resource.name;
+                                    while (pathIndex < pathLen) {
+                                        const dataType = nested
+                                            ? this.service.getDataType(nested.property.type || 'string')
+                                            : query.resource.dataType;
+                                        if (!(dataType instanceof ComplexType))
+                                            throw new Error(`"${path}" is not a ComplexType and has no properties.`);
+                                        p = url.path.get(pathIndex++);
+                                        path += '.' + p.resource;
+                                        const prop = dataType.properties?.[p.resource];
+                                        if (!prop)
+                                            throw new NotFoundError({ message: `Invalid or unknown resource path (${path})` });
+                                        const q = ExecutionQuery.forProperty(prop);
+                                        if (nested) {
+                                            nested.nested = q;
+                                        }
+                                        else {
+                                            query.nested = q;
+                                        }
+                                        nested = q;
+                                    }
+                                }
+                                break;
+                            }
+                            case 'DELETE': {
+                                if (scope === 'collection') {
+                                    query = ExecutionQuery.forDeleteMany(resource, {
+                                        filter: url.searchParams.get('$filter'),
+                                    });
+                                }
+                                else {
+                                    query = ExecutionQuery.forDelete(resource, p.key);
+                                }
+                                break;
+                            }
+                            case 'POST': {
+                                if (scope === 'collection') {
+                                    query = ExecutionQuery.forCreate(resource, body, {
+                                        pick: url.searchParams.get('$pick'),
+                                        omit: url.searchParams.get('$omit'),
+                                        include: url.searchParams.get('$include')
+                                    });
+                                }
+                                break;
+                            }
+                            case 'PATCH': {
+                                if (scope === 'collection') {
+                                    query = ExecutionQuery.forUpdateMany(resource, body, {
+                                        filter: url.searchParams.get('$filter')
+                                    });
+                                }
+                                else {
+                                    query = ExecutionQuery.forUpdate(resource, p.key, body, {
+                                        pick: url.searchParams.get('$pick'),
+                                        omit: url.searchParams.get('$omit'),
+                                        include: url.searchParams.get('$include')
+                                    });
+                                }
+                                break;
+                            }
+                        }
+                        return query;
+                    }
+                }
+            }
+            throw new InternalServerError();
+        }
+        catch (e) {
+            if (e instanceof ApiException)
+                throw e;
+            throw new BadRequestError({ message: e.message });
+        }
+    }
+    async sendResponse(adapterContext, executionContexts) {
+        const outputPackets = [];
+        for (const ctx of executionContexts) {
+            const v = this.createOutput(ctx);
+            outputPackets.push(v);
+        }
+        if (this.isBatch(adapterContext)) {
+            // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
+            return;
+        }
+        if (!outputPackets.length) {
+            const err = new NotFoundError();
+            outputPackets.push({
+                status: err.status,
+                body: {
+                    errors: [err.response]
+                }
+            });
+        }
+        const out = outputPackets[0];
+        const resp = adapterContext.getResponse();
+        resp.setStatus(out.status);
+        resp.setHeader(HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(HttpHeaders.Expires, '-1');
+        resp.setHeader(HttpHeaders.X_Opra_Version, OpraVersion);
+        if (out.headers) {
+            for (const [k, v] of Object.entries(out.headers)) {
+                resp.setHeader(k, v);
+            }
+        }
+        resp.send(JSON.stringify(out.body));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isBatch(adapterContext) {
+        return false;
+    }
+    createOutput(ctx) {
+        const { query } = ctx.request;
+        // Determine response status
+        let status = ctx.response.status;
+        if (ctx.response.errors.length) {
+            if (!status || status < 400) {
+                status = 0;
+                for (const e of ctx.response.errors) {
+                    status = Math.max(status, e.status || status);
+                }
+                if (status < HttpStatus.BAD_REQUEST)
+                    status = HttpStatus.INTERNAL_SERVER_ERROR;
+            }
+        }
+        else
+            status = status || (query.operationType === 'create' ? HttpStatus.CREATED : HttpStatus.OK);
+        let body;
+        let value = ctx.response.value;
+        if (query.queryType === 'search') {
+            body = {
+                // '@origin': ctx.resource.name + (ctx.request.resultPath ? '.' + ctx.request.resultPath : ''),
+                items: ctx.response.value,
+                total: ctx.response.total
+            };
+        }
+        else {
+            // Move to sub property if result path defined
+            if (value && ctx.request.resultPath) {
+                const pathArray = ctx.request.resultPath.split('.');
+                for (const property of pathArray) {
+                    value = value && typeof value === 'object' && value[property];
+                }
+            }
+            body = value;
+        }
+        if (ctx.response.errors?.length) {
+            body = body || {};
+            body.errors = ctx.response.errors.map(e => e.response);
+        }
+        return {
+            status,
+            headers: ctx.response.headers,
+            body
+        };
+    }
+    async sendError(adapterContext, error) {
+        const resp = adapterContext.getResponse();
+        resp.setStatus(error.status || 500);
+        resp.setHeader(HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(HttpHeaders.Expires, '-1');
+        resp.setHeader(HttpHeaders.X_Opra_Version, OpraVersion);
+        resp.send(JSON.stringify(error.response));
+    }
+}

package/esm/implementation/data-type/complex-type.d.ts

@@ -0,0 +1,18 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { ResponsiveObject } from '../../utils/responsive-object.js';
+import { nodeInspectCustom } from '../../utils/terminal-utils.js';
+import type { OpraDocument } from '../opra-document.js';
+import { DataType } from './data-type.js';
+export declare type ComplexTypeArgs = StrictOmit<OpraSchema.ComplexType, 'kind'>;
+export declare class ComplexType extends DataType {
+    protected readonly _args: StrictOmit<ComplexTypeArgs, 'properties'>;
+    readonly ownProperties?: ResponsiveObject<OpraSchema.Property>;
+    readonly properties?: ResponsiveObject<OpraSchema.Property>;
+    constructor(owner: OpraDocument, args: ComplexTypeArgs, base?: ComplexType);
+    get abstract(): boolean;
+    get additionalProperties(): boolean | string | Pick<OpraSchema.Property, 'type' | 'format' | 'isArray' | 'enum'> | undefined;
+    getProperty(name: string): OpraSchema.Property;
+    toString(): string;
+    [nodeInspectCustom](): string;
+}

package/esm/implementation/data-type/complex-type.js

@@ -0,0 +1,35 @@
+import { Responsive } from '../../utils/responsive-object.js';
+import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../../utils/terminal-utils.js';
+import { DataType } from './data-type.js';
+export class ComplexType extends DataType {
+    ownProperties;
+    properties;
+    constructor(owner, args, base) {
+        super(owner, {
+            kind: 'ComplexType',
+            ...args
+        }, base);
+        this.ownProperties = args?.properties && Responsive(args.properties);
+        this.properties = (base?.properties || this.ownProperties) &&
+            Responsive({ ...base?.properties, ...this.ownProperties });
+    }
+    get abstract() {
+        return !!this._args.abstract;
+    }
+    get additionalProperties() {
+        return this._args.additionalProperties;
+    }
+    getProperty(name) {
+        const t = this.properties?.[name];
+        if (!t)
+            throw new Error(`"${this.name}" type has no property named "${name}"`);
+        return t;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [nodeInspectCustom]() {
+        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
+            ` ${colorFgMagenta + this.name + colorReset}]`;
+    }
+}

package/esm/implementation/data-type/data-type.d.ts

@@ -0,0 +1,15 @@
+import { Type } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import type { OpraDocument } from '../opra-document.js';
+export declare abstract class DataType {
+    protected _owner: OpraDocument;
+    protected readonly _args: any;
+    readonly base?: DataType;
+    protected constructor(owner: OpraDocument, args: OpraSchema.DataType, base?: DataType);
+    get owner(): OpraDocument;
+    get kind(): OpraSchema.DataTypeKind;
+    get name(): string;
+    get description(): string | undefined;
+    get ctor(): Type;
+    is(typeName: string): boolean;
+}

package/esm/implementation/data-type/data-type.js

@@ -0,0 +1,31 @@
+export class DataType {
+    _owner;
+    _args;
+    base;
+    constructor(owner, args, base) {
+        this._args = { ...args };
+        this._owner = owner;
+        if (base) {
+            this.base = base;
+            Object.setPrototypeOf(this._args, base._args);
+        }
+    }
+    get owner() {
+        return this._owner;
+    }
+    get kind() {
+        return this._args.kind;
+    }
+    get name() {
+        return this._args.name;
+    }
+    get description() {
+        return this._args.description;
+    }
+    get ctor() {
+        return this._args.ctor;
+    }
+    is(typeName) {
+        return this.name === typeName || !!(this.base && this.base.is(typeName));
+    }
+}

package/esm/implementation/data-type/entity-type.d.ts

@@ -0,0 +1,10 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { OpraDocument } from '../opra-document.js';
+import { ComplexType } from './complex-type.js';
+export declare type EntityTypeArgs = StrictOmit<OpraSchema.EntityType, 'kind'>;
+export declare class EntityType extends ComplexType {
+    protected readonly _args: StrictOmit<EntityTypeArgs, 'properties'>;
+    constructor(owner: OpraDocument, args: EntityTypeArgs, base?: ComplexType | EntityType);
+    get primaryKey(): string;
+}

package/esm/implementation/data-type/entity-type.js

@@ -0,0 +1,29 @@
+import { SqbConnect } from '@opra/optionals';
+import { ComplexType } from './complex-type.js';
+export class EntityType extends ComplexType {
+    constructor(owner, args, base) {
+        super(owner, {
+            ...args
+        }, base);
+        this._args.kind = 'EntityType';
+        // Try to determine primary key info from SQB
+        if (args.ctor) {
+            const sqbEntity = SqbConnect.EntityMetadata.get(args.ctor);
+            if (sqbEntity?.indexes) {
+                const primaryIndex = sqbEntity.indexes.find(x => x.primary);
+                if (primaryIndex) {
+                    if (primaryIndex.columns.length > 1)
+                        throw new TypeError(`Multi-key indexes is not implemented yet`);
+                    this._args.primaryKey = primaryIndex.columns[0];
+                }
+            }
+        }
+        if (!this.primaryKey)
+            throw new TypeError(`You must provide primaryKey fo "${this.name}" entity`);
+        if (!this.getProperty(this.primaryKey))
+            throw new TypeError(`"${this.name}" entity has no such property named "${this.primaryKey}" which defined as primary key`);
+    }
+    get primaryKey() {
+        return this._args.primaryKey;
+    }
+}

package/esm/implementation/data-type/simple-type.d.ts

@@ -0,0 +1,15 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { nodeInspectCustom } from '../../utils/terminal-utils.js';
+import type { OpraDocument } from '../opra-document.js';
+import { DataType } from './data-type.js';
+export declare class SimpleType extends DataType {
+    protected readonly _args: OpraSchema.SimpleType;
+    readonly base?: SimpleType;
+    constructor(owner: OpraDocument, args: StrictOmit<OpraSchema.SimpleType, 'kind'>, base?: SimpleType);
+    get type(): 'boolean' | 'number' | 'integer' | 'string';
+    get format(): string | undefined;
+    get default(): boolean | number | string | undefined;
+    toString(): string;
+    [nodeInspectCustom](): string;
+}