@opra/common 1.0.0-alpha.3 → 1.0.0-alpha.30

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

@@ -1,4 +1,4 @@
-import { StrictOmit } from 'ts-gems';
+import { StrictOmit, Type } 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';
@@ -23,6 +23,9 @@ export declare namespace DataType {
         caseInSensitive?: boolean;
         partial?: boolean | 'deep';
         projection?: string[] | FieldsProjection | '*';
+        ignoreReadonlyFields?: boolean;
+        ignoreWriteonlyFields?: boolean;
+        ignoreHiddenFields?: boolean;
     }
 }
 interface DataTypeStatic {
@@ -52,7 +55,7 @@ declare abstract class DataTypeClass extends DocumentElement {
     readonly examples?: OpraSchema.DataTypeExample[];
     abstract generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
     get embedded(): any;
-    abstract extendsFrom(baseType: DataType): boolean;
+    abstract extendsFrom(baseType: DataType | string | Type | object): boolean;
     toJSON(): OpraSchema.DataType;
     toString(): string;
     [nodeInspectCustom](): string;

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

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { Combine } from 'ts-gems';
+import { Combine, Type } from 'ts-gems';
 import { Validator } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import type { DocumentElement } from '../common/document-element.js';
@@ -63,7 +63,7 @@ declare class EnumTypeClass extends DataType {
     readonly instance?: object;
     readonly attributes: Record<string | number, OpraSchema.EnumType.ValueInfo>;
     readonly ownAttributes: Record<string | number, OpraSchema.EnumType.ValueInfo>;
-    extendsFrom(baseType: DataType): boolean;
+    extendsFrom(baseType: DataType | string | Type | object): boolean;
     generateCodec(): Validator;
     toJSON(): OpraSchema.EnumType;
 }

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

@@ -1,11 +1,11 @@
 import 'reflect-metadata';
 import { Combine, Type } from 'ts-gems';
-import type { Field } from '../../schema/data-type/field.interface';
+import type { Field } from '../../schema/data-type/field.interface.js';
 import { OpraSchema } from '../../schema/index.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 { DataType } from './data-type.js';
 import type { MixinType } from './mixin-type';
 /**
  * @namespace MappedType
@@ -67,7 +67,7 @@ declare class MappedTypeClass extends ComplexTypeBase {
     readonly pick?: Field.Name[];
     readonly partial?: Field.Name[] | boolean;
     readonly required?: Field.Name[] | boolean;
-    extendsFrom(baseType: DataType): boolean;
+    extendsFrom(baseType: DataType | string | Type | object): boolean;
     toJSON(): OpraSchema.MappedType;
 }
 export {};

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

@@ -4,7 +4,7 @@ import { OpraSchema } from '../../schema/index.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 { DataType } from './data-type.js';
 import type { MappedType } from './mapped-type.js';
 /**
  * @namespace MixinType
@@ -76,7 +76,7 @@ export declare const MixinType: MixinTypeStatic;
 declare class MixinTypeClass extends ComplexTypeBase {
     readonly kind: OpraSchema.MixinType.Kind;
     readonly types: (ComplexType | MixinType | MappedType)[];
-    extendsFrom(baseType: DataType): boolean;
+    extendsFrom(baseType: DataType | string | Type | object): boolean;
     toJSON(): OpraSchema.MixinType;
 }
 export {};

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

@@ -1,11 +1,5 @@
 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

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

@@ -1,11 +1,5 @@
 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

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

@@ -6,11 +6,11 @@ import type { DataType } from './data-type.js';
  * @param keys
  * @param options
  */
-export declare function PickType(baseType: string | Type, keys: string[], options?: DataType.Options): Type;
+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'>;
 /**
  * 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'>;
+export declare function PickType(baseType: string | Type, keys: string[], options?: DataType.Options): Type;

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

@@ -1,12 +1,5 @@
 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
@@ -20,3 +13,10 @@ export declare function RequiredType<Args extends any[], Instance, Static, K ext
  * @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'>;
+/**
+ * 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;

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

@@ -14,7 +14,7 @@ export declare namespace SimpleType {
         kind: OpraSchema.SimpleType.Kind;
     }, DataType.Metadata, OpraSchema.SimpleType> {
     }
-    interface Options extends DataType.Options {
+    interface Options extends Combine<Pick<OpraSchema.SimpleType, 'nameMappings'>, DataType.Options> {
     }
     interface InitArguments extends Combine<{
         kind: OpraSchema.SimpleType.Kind;
@@ -64,11 +64,13 @@ 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;
-    extendsFrom(baseType: DataType): boolean;
+    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(): OpraSchema.SimpleType;
 }

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

@@ -6,6 +6,7 @@ export interface HttpControllerDecorator<T extends HttpControllerDecorator<any>
     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;
+    KeyParam(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync | false): T;
     UseType(...type: TypeThunkAsync[]): T;
 }
 export interface HttpControllerDecoratorFactory {

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

@@ -63,6 +63,7 @@ declare module '../http/http-operation' {
             interface FindManyArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
                 type: Type | string;
                 defaultLimit?: number;
+                defaultProjection?: string[];
                 maxLimit?: number;
             }
             /** Get */

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

@@ -18,24 +18,29 @@ export declare namespace DataTypeFactory {
     type DataTypeSources = ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray | object>[] | Record<string, OpraSchema.DataType>;
     type DataTypeThunk = Type | EnumType.EnumObject | EnumType.EnumArray | object;
     interface ComplexTypeInit extends Combine<{
+        _instance?: ComplexType;
         base?: string | ComplexTypeInit | MappedTypeInit | MixinTypeInit;
         fields?: Record<string, ApiFieldInit>;
         additionalFields?: boolean | string | DataTypeFactory.DataTypeInitArguments | ['error'] | ['error', string];
     }, ComplexType.InitArguments> {
     }
     interface EnumTypeInit extends Combine<{
+        _instance?: MappedType;
         base?: string | EnumTypeInit;
     }, EnumType.InitArguments> {
     }
     interface MappedTypeInit extends Combine<{
+        _instance?: MappedType;
         base: string | ComplexTypeInit | MappedTypeInit | MixinTypeInit;
     }, MappedType.InitArguments> {
     }
     interface MixinTypeInit extends Combine<{
+        _instance?: MixinType;
         types: (string | ComplexTypeInit | MappedTypeInit | MixinTypeInit)[];
     }, MixinType.InitArguments> {
     }
     interface SimpleTypeInit extends Combine<{
+        _instance?: SimpleType;
         base?: string | SimpleTypeInit;
     }, SimpleType.InitArguments> {
     }

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

@@ -76,6 +76,7 @@ declare class HttpControllerClass extends DocumentElement {
     findController(controller: Type): HttpController | undefined;
     findController(resourcePath: string): HttpController | undefined;
     findParameter(paramName: string, location?: OpraSchema.HttpParameterLocation): HttpParameter | undefined;
+    getFullUrl(): string;
     /**
      *
      */

package/types/document/http/http-media-type.d.ts

@@ -1,4 +1,5 @@
 import { Combine, StrictOmit, Type } from 'ts-gems';
+import { Validator } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import { DocumentElement } from '../common/document-element.js';
 import { DataType } from '../data-type/data-type.js';
@@ -52,8 +53,8 @@ declare class HttpMediaTypeClass extends DocumentElement {
     maxFiles?: number;
     maxFileSize?: number;
     maxTotalFileSize?: number;
-    minFileSize?: number;
     findMultipartField(fieldName: string, fieldType?: OpraSchema.HttpMultipartFieldType): HttpMultipartField | undefined;
     toJSON(): OpraSchema.HttpMediaType;
+    generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
 }
 export {};

package/types/document/http/http-operation.d.ts

@@ -13,20 +13,20 @@ import type { HttpRequestBody } from './http-request-body.js';
  * @namespace HttpOperation
  */
 export declare namespace HttpOperation {
-    interface Metadata extends Pick<OpraSchema.HttpOperation, 'description' | 'path' | 'method' | 'composition' | 'compositionOptions'> {
+    interface Metadata extends Pick<OpraSchema.HttpOperation, 'description' | 'method' | 'path' | 'mergePath' | 'composition' | 'compositionOptions'> {
         types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
         parameters?: HttpParameter.Metadata[];
         responses?: HttpOperationResponse.Metadata[];
         requestBody?: HttpRequestBody.Metadata;
         immediateFetch?: boolean;
     }
-    interface Options extends Partial<Pick<Metadata, 'path' | 'description' | 'method' | 'immediateFetch'>> {
+    interface Options extends Partial<Pick<Metadata, 'path' | 'mergePath' | 'description' | 'method' | 'immediateFetch'>> {
         requestBody?: HttpRequestBody.Options;
     }
     interface InitArguments extends Combine<{
         name: string;
         types?: DataType[];
-    }, Pick<Metadata, 'description' | 'path' | 'method' | 'composition' | 'compositionOptions' | 'immediateFetch'>> {
+    }, Pick<Metadata, 'description' | 'method' | 'path' | 'mergePath' | 'composition' | 'compositionOptions' | 'immediateFetch'>> {
     }
 }
 /**
@@ -72,6 +72,7 @@ declare class HttpOperationClass extends DocumentElement {
     method: OpraSchema.HttpMethod;
     description?: string;
     path?: string;
+    mergePath?: boolean;
     types: DataTypeMap;
     parameters: HttpParameter[];
     responses: HttpOperationResponse[];
@@ -79,6 +80,7 @@ declare class HttpOperationClass extends DocumentElement {
     composition?: string;
     compositionOptions?: Record<string, any>;
     findParameter(paramName: string, location?: OpraSchema.HttpParameterLocation): HttpParameter | undefined;
+    getFullUrl(): string;
     toJSON(): OpraSchema.HttpOperation;
 }
 export {};

package/types/document/http/http-parameter.d.ts

@@ -1,6 +1,5 @@
 import { Combine, StrictOmit, TypeThunkAsync } from 'ts-gems';
 import type { OpraSchema } from '../../schema/index.js';
-import { HttpParameterLocation } from '../../schema/types.js';
 import { DocumentElement } from '../common/document-element.js';
 import { Value } from '../common/value.js';
 import { DataType } from '../data-type/data-type.js';
@@ -12,6 +11,7 @@ export declare namespace HttpParameter {
     interface Metadata extends StrictOmit<OpraSchema.HttpParameter, 'type'> {
         name: string | RegExp;
         type?: string | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
+        keyParam?: boolean;
     }
     interface Options extends Partial<StrictOmit<Metadata, 'type'>> {
         type?: string | TypeThunkAsync | object;
@@ -41,10 +41,11 @@ export declare const HttpParameter: HttpParameterStatic;
  */
 declare class HttpParameterClass extends Value {
     readonly owner: DocumentElement;
+    location: OpraSchema.HttpParameterLocation;
+    keyParam?: boolean;
     deprecated?: boolean | string;
     required?: boolean;
     arraySeparator?: string;
-    location: HttpParameterLocation;
     toJSON(): OpraSchema.HttpParameter;
 }
 export {};

package/types/document/http/http-status-range.d.ts

@@ -8,7 +8,8 @@ export declare class HttpStatusRange {
     constructor(value: string);
     constructor(start: number, end?: number);
     constructor(init: Pick<HttpStatusRange, 'start' | 'end'>);
-    get distance(): number;
+    includes(statusCode: number): boolean;
+    intersects(start: number, end: number): boolean;
     toString(): string;
     toJSON(): OpraSchema.HttpStatusRange | number;
 }

package/types/document/index.d.ts

@@ -2,36 +2,36 @@ import 'reflect-metadata';
 import * as DataTypeFactory_ from './factory/data-type.factory.js';
 import * as HttpApiFactory_ from './factory/http-api.factory.js';
 export * from './api-document.js';
-export * from './constants.js';
 export * from './common/api-base.js';
 export * from './common/data-type-map.js';
 export * from './common/document-element.js';
 export * from './common/document-init-context.js';
 export * from './common/document-node.js';
 export * from './common/opra-document-error.js';
+export * from './constants.js';
+export * from './data-type/api-field.js';
 export * from './data-type/complex-type.js';
 export * from './data-type/data-type.js';
 export * from './data-type/enum-type.js';
-export * from './data-type/api-field.js';
+export * from './data-type/extended-types/index.js';
 export * from './data-type/mapped-type.js';
 export * from './data-type/mixin-type.js';
 export * from './data-type/omit-type.js';
 export * from './data-type/partial-type.js';
 export * from './data-type/pick-type.js';
+export * from './data-type/primitive-types/index.js';
 export * from './data-type/required-type.js';
 export * from './data-type/simple-type.js';
-export * from './data-type/primitive-types/index.js';
-export * from './data-type/extended-types/index.js';
 export * from './decorators/http-operation-entity.decorator.js';
 export * from './factory/api-document.factory.js';
 export * from './http/http-api.js';
+export * from './http/http-controller.js';
 export * from './http/http-media-type.js';
 export * from './http/http-multipart-field.js';
 export * from './http/http-operation.js';
 export * from './http/http-operation-response.js';
 export * from './http/http-parameter.js';
 export * from './http/http-request-body.js';
-export * from './http/http-controller.js';
 export * from './http/http-status-range.js';
 export declare namespace classes {
     export import HttpApiFactory = HttpApiFactory_.HttpApiFactory;

package/types/exception/index.d.ts

@@ -1,7 +1,4 @@
-export * from './opra-exception.js';
-export * from './opra-http-error.js';
 export * from './error-issue.js';
-export * from './issue-severity.enum.js';
 export * from './http-errors/bad-request.error.js';
 export * from './http-errors/conflict.error.js';
 export * from './http-errors/failed-dependency.error.js';
@@ -10,8 +7,11 @@ export * from './http-errors/internal-server.error.js';
 export * from './http-errors/method-not-allowed.error.js';
 export * from './http-errors/not-acceptable.error.js';
 export * from './http-errors/not-found.error.js';
-export * from './http-errors/unauthorized.error.js';
-export * from './http-errors/unprocessable-entity.error.js';
 export * from './http-errors/permission.error.js';
 export * from './http-errors/resource-conflict.error.js';
 export * from './http-errors/resource-not.available.error.js';
+export * from './http-errors/unauthorized.error.js';
+export * from './http-errors/unprocessable-entity.error.js';
+export * from './issue-severity.enum.js';
+export * from './opra-exception.js';
+export * from './opra-http-error.js';

package/types/filter/ast/index.d.ts

@@ -6,8 +6,8 @@ export * from './expressions/arithmetic-expression.js';
 export * from './expressions/array-expression.js';
 export * from './expressions/comparison-expression.js';
 export * from './expressions/logical-expression.js';
-export * from './expressions/parenthesized-expression.js';
 export * from './expressions/negative-expression.js';
+export * from './expressions/parenthesized-expression.js';
 export * from './terms/boolean-literal.js';
 export * from './terms/date-literal.js';
 export * from './terms/null-literal.js';

package/types/filter/opra-filter.ns.d.ts

@@ -1,5 +1,5 @@
 export * from './ast/index.js';
-export * from './parse.js';
 export * from './build.js';
-export * from './opra-error-listener.js';
 export * from './filter-tree-visitor.js';
+export * from './opra-error-listener.js';
+export * from './parse.js';

package/types/helpers/type-guards.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference lib="dom" />
 import { Readable, Stream } from 'stream';
 import { Type } from 'ts-gems';
 export declare function isConstructor(fn: any): fn is Type;

package/types/i18n/i18n.d.ts

@@ -1,26 +1,28 @@
-import { Type } from 'ts-gems';
-import { FallbackLng, Formatter as I18nextFormatter, i18n, InitOptions as I18nextInitOptions, Resource as I18nextResource, TFunction as I18nextTFunction, TOptions } from '@browsery/i18next';
+import { FallbackLng as I18nextFallbackLng, Formatter as I18nextFormatter, i18n, InitOptions as I18nextInitOptions, Resource as I18nextResource, TFunction as I18nextTFunction, TOptions } from '@browsery/i18next';
 import * as I18next from '@browsery/i18next';
+import { Type } from 'ts-gems';
 export interface BaseI18n extends Type<I18next.i18n> {
 }
-export declare const BaseI18n: BaseI18n;
-export type DeepTranslateOptions = TOptions & {
-    ignore?: (input: any, inst: i18n) => boolean;
-};
-export type InitCallback = I18next.Callback;
-export type TranslateFunction = I18nextTFunction;
-export type Formatter = I18nextFormatter;
-export type LanguageResource = I18nextResource;
-export type { FallbackLng };
-export interface InitOptions extends I18nextInitOptions {
-    resourceDirs?: string[];
+export declare namespace I18n {
+    interface InitOptions extends I18nextInitOptions {
+        resourceDirs?: string[];
+    }
+    type DeepTranslateOptions = TOptions & {
+        ignore?: (input: any, inst: i18n) => boolean;
+    };
+    type InitCallback = I18next.Callback;
+    type TranslateFunction = I18nextTFunction;
+    type Formatter = I18nextFormatter;
+    type LanguageResource = I18nextResource;
+    type FallbackLng = I18nextFallbackLng;
 }
+export declare const BaseI18n: BaseI18n;
 export declare class I18n extends BaseI18n {
-    init(callback?: InitCallback): Promise<TranslateFunction>;
-    init(options: InitOptions, callback?: InitCallback): Promise<TranslateFunction>;
-    deep(input: any, options?: DeepTranslateOptions): any;
-    createInstance(options: {} | undefined, callback: any): I18n;
-    static createInstance(options?: InitOptions, callback?: InitCallback): I18n;
-    protected _deepTranslate(input: any, objectStack: WeakMap<object, any>, options?: DeepTranslateOptions): any;
+    init(callback?: I18n.InitCallback): Promise<I18n.TranslateFunction>;
+    init(options: I18n.InitOptions, callback?: I18n.InitCallback): Promise<I18n.TranslateFunction>;
+    deep(input: any, options?: I18n.DeepTranslateOptions): any;
+    createInstance(options?: I18n.InitOptions, callback?: I18n.InitCallback): I18n;
+    static createInstance(options?: I18n.InitOptions, callback?: I18n.InitCallback): I18n;
+    protected _deepTranslate(input: any, objectStack: WeakMap<object, any>, options?: I18n.DeepTranslateOptions): any;
     static get defaultInstance(): I18n;
 }

package/types/index.d.ts

@@ -1,4 +1,3 @@
-export * from './types.js';
 export * from './document/index.js';
 export * from './exception/index.js';
 export * from './filter/index.js';
@@ -6,4 +5,5 @@ export * from './helpers/index.js';
 export * from './http/index.js';
 export * from './i18n/index.js';
 export * from './schema/index.js';
+export * from './types.js';
 export { uid } from 'uid';

package/types/schema/data-type/data-type.interface.d.ts

@@ -1,7 +1,7 @@
 import type { ComplexType } from './complex-type.interface.js';
 import type { EnumType } from './enum-type.interface.js';
 import type { MappedType } from './mapped-type.interface.js';
-import type { MixinType } from './mixin-type.interface';
+import type { MixinType } from './mixin-type.interface.js';
 import type { SimpleType } from './simple-type.interface.js';
 export type DataType = SimpleType | EnumType | ComplexType | MappedType | MixinType;
 export declare namespace DataType {

package/types/schema/data-type/mapped-type.interface.d.ts

@@ -1,6 +1,6 @@
 import { StrictOmit } from 'ts-gems';
-import type { ComplexType } from './complex-type.interface';
-import type { DataType, DataTypeBase } from './data-type.interface';
+import type { ComplexType } from './complex-type.interface.js';
+import type { DataType, DataTypeBase } from './data-type.interface.js';
 import type { Field } from './field.interface.js';
 import type { MixinType } from './mixin-type.interface.js';
 export interface MappedType extends StrictOmit<DataTypeBase, 'kind'> {

package/types/schema/data-type/simple-type.interface.d.ts

@@ -9,6 +9,10 @@ export interface SimpleType extends StrictOmit<DataTypeBase, 'kind'> {
     base?: DataType.Name;
     attributes?: Record<string, Attribute>;
     properties?: Record<string, any>;
+    /**
+     * Naming alternatives across software languages
+     */
+    nameMappings?: Record<string, string>;
 }
 export declare namespace SimpleType {
     const Kind = "SimpleType";

package/types/schema/data-type-container.interface.d.ts

@@ -1,4 +1,4 @@
-import type { DataType } from './data-type/data-type.interface';
+import type { DataType } from './data-type/data-type.interface.js';
 /**
  * @interface DataTypeContainer
  */

package/types/schema/document.interface.d.ts

@@ -1,6 +1,6 @@
 import type { SpecVersion } from './constants.js';
 import type { DataTypeContainer } from './data-type-container.interface.js';
-import type { HttpController } from './http/http-controller.interface';
+import type { HttpController } from './http/http-controller.interface.js';
 export type Protocol = 'http' | 'ws' | 'rpc';
 /**
  * @interface Document

package/types/schema/http/http-controller.interface.d.ts

@@ -1,6 +1,6 @@
 import type { DataTypeContainer } from '../data-type-container.interface.js';
-import type { HttpOperation } from './http-operation.interface';
-import type { HttpParameter } from './http-parameter.interface';
+import type { HttpOperation } from './http-operation.interface.js';
+import type { HttpParameter } from './http-parameter.interface.js';
 /**
  *
  * @interface HttpController

package/types/schema/http/http-media-type.interface.d.ts

@@ -1,4 +1,4 @@
-import type { DataType } from '../data-type/data-type.interface';
+import type { DataType } from '../data-type/data-type.interface.js';
 import type { HttpMultipartField } from './http-multipart-field.interface.js';
 /**
  *

package/types/schema/http/http-operation-response.interface.d.ts

@@ -1,6 +1,6 @@
 import type { HttpMediaType } from './http-media-type.interface.js';
-import type { HttpParameter } from './http-parameter.interface';
-import type { HttpStatusRange } from './http-status-range.interface';
+import type { HttpParameter } from './http-parameter.interface.js';
+import type { HttpStatusRange } from './http-status-range.interface.js';
 /**
  *
  * @interface HttpOperationResponse

package/types/schema/http/http-operation.interface.d.ts

@@ -1,8 +1,8 @@
-import type { DataTypeContainer } from '../data-type-container.interface';
+import type { DataTypeContainer } from '../data-type-container.interface.js';
 import type { HttpMethod } from '../types.js';
-import type { HttpOperationResponse } from './http-operation-response.interface';
-import type { HttpParameter } from './http-parameter.interface';
-import type { HttpRequestBody } from './http-request-body.interface';
+import type { HttpOperationResponse } from './http-operation-response.interface.js';
+import type { HttpParameter } from './http-parameter.interface.js';
+import type { HttpRequestBody } from './http-request-body.interface.js';
 /**
  * @interface HttpOperation
  */
@@ -11,6 +11,10 @@ export interface HttpOperation extends DataTypeContainer {
     method: HttpMethod;
     description?: string;
     path?: string;
+    /**
+     * Determines if the `path` will be joined or merged to parent path.
+     */
+    mergePath?: boolean;
     parameters?: HttpParameter[];
     responses?: HttpOperationResponse[];
     requestBody?: HttpRequestBody;

package/types/schema/http/http-parameter.interface.d.ts

@@ -1,5 +1,5 @@
 import { HttpParameterLocation } from '../types.js';
-import type { Value } from '../value.interface';
+import type { Value } from '../value.interface.js';
 /**
  *
  * @interface HttpParameter
@@ -13,6 +13,10 @@ export interface HttpParameter extends Value {
      * Name of the parameter. RegExp pattern can be used matching parameter name
      */
     name: string | RegExp;
+    /**
+     * Determines if parameter is key
+     */
+    keyParam?: boolean;
     /**
      * Defines array separator
      */