@opra/client 0.7.0 → 0.8.0

package/typings/common/schema/implementation/data-type/complex-type.d.ts

@@ -0,0 +1,29 @@
+import { StrictOmit } from 'ts-gems';
+import { ResponsiveMap } from '../../../helpers/responsive-map.js';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { nodeInspectCustom } from '../../utils/inspect.util.js';
+import type { OpraDocument } from '../opra-document';
+import { DataType } from './data-type.js';
+export declare type ComplexTypeArgs = StrictOmit<OpraSchema.ComplexType, 'kind'>;
+export declare class ComplexType extends DataType {
+    protected _initialized: boolean;
+    protected _metadata: OpraSchema.ComplexType;
+    private _mixinAdditionalFields;
+    readonly ownFields: ResponsiveMap<string, Field>;
+    readonly fields: ResponsiveMap<string, Field>;
+    constructor(owner: OpraDocument, name: any, args: ComplexTypeArgs);
+    get abstract(): boolean;
+    get additionalFields(): string | boolean | Pick<OpraSchema.Field, "type" | "format" | "isArray" | "enum">;
+    get extends(): OpraSchema.ComplexTypeExtendingInfo[] | undefined;
+    getField(fieldName: string): Field;
+    getFieldType(fieldName: string): DataType;
+    getOwnField(name: string): Field;
+    getSchema(): OpraSchema.ComplexType;
+    toString(): string;
+    [nodeInspectCustom](): string;
+    init(): void;
+}
+export interface Field extends OpraSchema.Field {
+    name: string;
+    parent: ComplexType;
+}

package/typings/common/schema/implementation/data-type/data-type.d.ts

@@ -0,0 +1,16 @@
+import { Type } from 'ts-gems';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import type { OpraDocument } from '../opra-document';
+export declare abstract class DataType {
+    protected _document: OpraDocument;
+    protected _metadata: OpraSchema.BaseDataType;
+    protected _name: string;
+    protected constructor(document: OpraDocument, name: any, metadata: OpraSchema.DataType);
+    get document(): OpraDocument;
+    get kind(): OpraSchema.DataTypeKind;
+    get name(): string;
+    get description(): string | undefined;
+    get ctor(): Type | undefined;
+    parse<T>(value: any): T;
+    getSchema(jsonOnly?: boolean): any;
+}

package/typings/common/schema/implementation/data-type/simple-type.d.ts

@@ -0,0 +1,12 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { nodeInspectCustom } from '../../utils/inspect.util.js';
+import type { OpraDocument } from '../opra-document';
+import { DataType } from './data-type.js';
+export declare class SimpleType extends DataType {
+    protected readonly _metadata: OpraSchema.SimpleType;
+    readonly base?: SimpleType;
+    constructor(owner: OpraDocument, name: string, args: StrictOmit<OpraSchema.SimpleType, 'kind'>);
+    toString(): string;
+    [nodeInspectCustom](): string;
+}

package/typings/common/schema/implementation/data-type/union-type.d.ts

@@ -0,0 +1,16 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { nodeInspectCustom } from '../../utils/inspect.util.js';
+import type { OpraDocument } from '../opra-document';
+import { DataType } from './data-type.js';
+export declare type UnionTypeArgs = StrictOmit<OpraSchema.UnionType, 'kind'> & {
+    types: DataType[];
+};
+export declare class UnionType extends DataType {
+    protected readonly _metadata: StrictOmit<OpraSchema.UnionType, 'types'>;
+    readonly types: DataType[];
+    readonly hasAdditionalFields: boolean;
+    constructor(owner: OpraDocument, name: string, args: UnionTypeArgs);
+    toString(): string;
+    [nodeInspectCustom](): string;
+}

package/typings/common/schema/implementation/document-builder.d.ts

@@ -0,0 +1,16 @@
+import { Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/responsive-map.js';
+import { OpraSchema } from '../opra-schema.definition.js';
+import { ThunkAsync } from '../types.js';
+export declare type DocumentBuilderArgs = Pick<OpraSchema.Document, 'info' | 'servers'>;
+export declare class DocumentBuilder {
+    protected _args: DocumentBuilderArgs;
+    protected _dataTypes: ResponsiveMap<string, OpraSchema.DataType>;
+    protected _resources: ResponsiveMap<string, OpraSchema.Resource>;
+    constructor(args: DocumentBuilderArgs);
+    buildSchema(): OpraSchema.Document;
+    addDataTypeSchema(name: string, schema: OpraSchema.DataType): Promise<void>;
+    addDataTypeClass(thunk: ThunkAsync<Type | Function>): Promise<string>;
+    addResourceSchema(name: string, schema: OpraSchema.Resource): Promise<void>;
+    addResourceInstance(thunk: ThunkAsync<any>): Promise<string>;
+}

package/typings/common/schema/implementation/opra-document.d.ts

@@ -0,0 +1,44 @@
+import { Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/responsive-map.js';
+import { IResourceContainer } from '../interfaces/resource-container.interface.js';
+import { OpraSchema } from '../opra-schema.definition.js';
+import { ThunkAsync } from '../types.js';
+import { ComplexType } from './data-type/complex-type.js';
+import { DataType } from './data-type/data-type.js';
+import { SimpleType } from './data-type/simple-type.js';
+import { UnionType } from './data-type/union-type.js';
+import { DocumentBuilderArgs } from './document-builder.js';
+import { CollectionResourceInfo } from './resource/collection-resource-info.js';
+import { ResourceInfo } from './resource/resource-info.js';
+import { SingletonResourceInfo } from './resource/singleton-resource-info.js';
+export declare type OpraDocumentArgs = DocumentBuilderArgs & {
+    types?: ThunkAsync<Type>[] | Record<string, OpraSchema.DataType>;
+    resources?: ThunkAsync<any>[] | Record<string, OpraSchema.Resource>;
+};
+declare type OpraDocumentMeta = Pick<OpraSchema.Document, 'info' | 'servers'>;
+export declare namespace OpraDocument {
+}
+export declare class OpraDocument implements IResourceContainer {
+    protected readonly _meta: OpraDocumentMeta;
+    protected _ownTypes: ResponsiveMap<string, DataType>;
+    protected _types: ResponsiveMap<string, DataType>;
+    protected _resources: ResponsiveMap<string, ResourceInfo>;
+    constructor(schema: OpraSchema.Document);
+    get info(): OpraSchema.DocumentInfo;
+    get types(): Map<string, DataType>;
+    getDataType(name: string): DataType;
+    getComplexDataType(name: string): ComplexType;
+    getSimpleDataType(name: string): SimpleType;
+    getUnionDataType(name: string): UnionType;
+    get resources(): Map<string, ResourceInfo>;
+    get servers(): OpraSchema.ServerInfo[] | undefined;
+    getResource<T extends ResourceInfo>(name: string): T;
+    getCollectionResource(name: string): CollectionResourceInfo;
+    getSingletonResource(name: string): SingletonResourceInfo;
+    getMetadata(jsonOnly?: boolean): OpraSchema.Document;
+    protected _addDataType(name: string, schema: OpraSchema.DataType, isOwn: boolean): DataType;
+    protected _addResource(name: string, schema: OpraSchema.Resource): void;
+    protected _initTypes(): void;
+    static create(args: OpraDocumentArgs): Promise<OpraDocument>;
+}
+export {};

package/typings/common/schema/implementation/query/collection-count-query.d.ts

@@ -0,0 +1,14 @@
+import { Expression } from '../../../filter/index.js';
+import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+export declare type CollectionCountQueryOptions = {
+    filter?: string | Expression;
+};
+export declare class CollectionCountQuery {
+    readonly resource: CollectionResourceInfo;
+    readonly kind = "CollectionCountQuery";
+    readonly method = "count";
+    readonly operation = "read";
+    filter?: Expression;
+    constructor(resource: CollectionResourceInfo, options?: CollectionCountQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/typings/common/schema/implementation/query/collection-create-query.d.ts

@@ -0,0 +1,18 @@
+import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+export declare type CollectionCreateQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+};
+export declare class CollectionCreateQuery {
+    readonly resource: CollectionResourceInfo;
+    data: {};
+    readonly kind = "CollectionCreateQuery";
+    readonly method = "create";
+    readonly operation = "create";
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    constructor(resource: CollectionResourceInfo, data: {}, options?: CollectionCreateQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/typings/common/schema/implementation/query/collection-delete-many-query.d.ts

@@ -0,0 +1,14 @@
+import { Expression } from '../../../filter/index.js';
+import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+export declare type CollectionDeleteManyQueryOptions = {
+    filter?: string | Expression;
+};
+export declare class CollectionDeleteManyQuery {
+    readonly resource: CollectionResourceInfo;
+    readonly kind = "CollectionDeleteManyQuery";
+    readonly method = "deleteMany";
+    readonly operation = "delete";
+    filter?: Expression;
+    constructor(resource: CollectionResourceInfo, options?: CollectionDeleteManyQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/typings/common/schema/implementation/query/collection-delete-query.d.ts

@@ -0,0 +1,10 @@
+import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+export declare class CollectionDeleteQuery {
+    readonly resource: CollectionResourceInfo;
+    readonly kind = "CollectionDeleteQuery";
+    readonly method = "delete";
+    readonly operation = "delete";
+    keyValue: any;
+    constructor(resource: CollectionResourceInfo, keyValue: any);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/typings/common/schema/implementation/query/collection-get-query.d.ts

@@ -0,0 +1,21 @@
+import type { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
+import type { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+import type { FieldGetQuery } from './field-get-query.js';
+export declare type CollectionGetQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+};
+export declare class CollectionGetQuery implements IChildFieldQuery {
+    readonly resource: CollectionResourceInfo;
+    readonly kind = "CollectionGetQuery";
+    readonly method = "get";
+    readonly operation = "read";
+    keyValue: any;
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    child?: FieldGetQuery;
+    constructor(resource: CollectionResourceInfo, keyValue: any, options?: CollectionGetQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/typings/common/schema/implementation/query/collection-search-query.d.ts

@@ -0,0 +1,30 @@
+import { Expression } from '../../../filter/index.js';
+import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+export declare type CollectionSearchQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    filter?: string | Expression;
+    limit?: number;
+    skip?: number;
+    distinct?: boolean;
+    count?: boolean;
+    sort?: string[];
+};
+export declare class CollectionSearchQuery {
+    readonly resource: CollectionResourceInfo;
+    readonly kind = "CollectionSearchQuery";
+    readonly method = "search";
+    readonly operation = "read";
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    filter?: Expression;
+    limit?: number;
+    skip?: number;
+    distinct?: boolean;
+    count?: boolean;
+    sort?: string[];
+    constructor(resource: CollectionResourceInfo, options?: CollectionSearchQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/typings/common/schema/implementation/query/collection-update-many-query.d.ts

@@ -0,0 +1,15 @@
+import { Expression } from '../../../filter/index.js';
+import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+export declare type CollectionUpdateManyQueryOptions = {
+    filter?: string | Expression;
+};
+export declare class CollectionUpdateManyQuery {
+    readonly resource: CollectionResourceInfo;
+    data: {};
+    readonly kind = "CollectionUpdateManyQuery";
+    readonly method = "updateMany";
+    readonly operation = "update";
+    filter?: Expression;
+    constructor(resource: CollectionResourceInfo, data: {}, options?: CollectionUpdateManyQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/typings/common/schema/implementation/query/collection-update-query.d.ts

@@ -0,0 +1,19 @@
+import { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+export declare type CollectionUpdateQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+};
+export declare class CollectionUpdateQuery {
+    readonly resource: CollectionResourceInfo;
+    data: any;
+    readonly kind = "CollectionUpdateQuery";
+    readonly method = "update";
+    readonly operation = "update";
+    keyValue: any;
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    constructor(resource: CollectionResourceInfo, keyValue: any, data: any, options?: CollectionUpdateQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/typings/common/schema/implementation/query/field-get-query.d.ts

@@ -0,0 +1,30 @@
+import type { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
+import { ComplexType, Field } from '../data-type/complex-type.js';
+import type { DataType } from '../data-type/data-type.js';
+import type { CollectionResourceInfo } from '../resource/collection-resource-info.js';
+import type { SingletonResourceInfo } from '../resource/singleton-resource-info.js';
+import type { CollectionGetQuery } from './collection-get-query.js';
+import type { SingletonGetQuery } from './singleton-get-query.js';
+export declare type FieldGetQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    castingType?: ComplexType;
+};
+export declare class FieldGetQuery implements IChildFieldQuery {
+    readonly parent: CollectionGetQuery | SingletonGetQuery | FieldGetQuery;
+    readonly resource: CollectionResourceInfo | SingletonResourceInfo;
+    readonly kind = "FieldGetQuery";
+    readonly method = "get";
+    readonly operation = "read";
+    readonly fieldName: string;
+    readonly field?: Field;
+    readonly path: string;
+    readonly dataType: DataType;
+    readonly parentType: ComplexType;
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    child?: FieldGetQuery;
+    constructor(parent: CollectionGetQuery | SingletonGetQuery | FieldGetQuery, fieldName: string, options?: FieldGetQueryOptions);
+}

package/typings/common/schema/implementation/query/index.d.ts

@@ -0,0 +1,27 @@
+import { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
+import { CollectionCountQuery } from './collection-count-query.js';
+import { CollectionCreateQuery } from './collection-create-query.js';
+import { CollectionDeleteManyQuery } from './collection-delete-many-query.js';
+import { CollectionDeleteQuery } from './collection-delete-query.js';
+import { CollectionGetQuery } from './collection-get-query.js';
+import { CollectionSearchQuery } from './collection-search-query.js';
+import { CollectionUpdateManyQuery } from './collection-update-many-query.js';
+import { CollectionUpdateQuery } from './collection-update-query.js';
+import { FieldGetQuery } from './field-get-query.js';
+import { SingletonGetQuery } from './singleton-get-query.js';
+export * from './collection-create-query.js';
+export * from './collection-count-query.js';
+export * from './collection-delete-many-query.js';
+export * from './collection-delete-query.js';
+export * from './collection-delete-many-query.js';
+export * from './collection-get-query.js';
+export * from './field-get-query.js';
+export * from './singleton-get-query.js';
+export * from './collection-search-query.js';
+export * from './collection-update-many-query.js';
+export * from './collection-update-query.js';
+export declare type CollectionQuery = CollectionCountQuery | CollectionCreateQuery | CollectionDeleteManyQuery | CollectionDeleteQuery | CollectionGetQuery | CollectionSearchQuery | CollectionUpdateManyQuery | CollectionUpdateQuery;
+export declare type FieldQuery = FieldGetQuery;
+export declare type SingletonQuery = SingletonGetQuery;
+export declare type OpraQuery = CollectionQuery | SingletonQuery | FieldQuery;
+export declare function isChildFieldQuery(query: any): query is IChildFieldQuery;

package/typings/common/schema/implementation/query/singleton-get-query.d.ts

@@ -0,0 +1,20 @@
+import type { IChildFieldQuery } from '../../interfaces/child-field-query.interface.js';
+import type { SingletonResourceInfo } from '../resource/singleton-resource-info.js';
+import type { FieldGetQuery } from './field-get-query.js';
+export declare type SingletonGetQueryOptions = {
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+};
+export declare class SingletonGetQuery implements IChildFieldQuery {
+    readonly resource: SingletonResourceInfo;
+    readonly kind = "SingletonGetQuery";
+    readonly method = "get";
+    readonly operation = "read";
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    child?: FieldGetQuery;
+    constructor(resource: SingletonResourceInfo, options?: SingletonGetQueryOptions);
+    get dataType(): import("../data-type/complex-type.js").ComplexType;
+}

package/typings/common/schema/implementation/resource/collection-resource-info.d.ts

@@ -0,0 +1,19 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import type { OpraDocument } from '../opra-document';
+import { ResourceInfo } from './resource-info.js';
+export declare class CollectionResourceInfo extends ResourceInfo {
+    readonly metadata: OpraSchema.CollectionResource;
+    readonly dataType: ComplexType;
+    constructor(document: OpraDocument, name: string, dataType: ComplexType, metadata: OpraSchema.CollectionResource);
+    get keyFields(): string[];
+    get create(): OpraSchema.CreateMethodResolver | undefined;
+    get count(): OpraSchema.MethodResolver | undefined;
+    get delete(): OpraSchema.MethodResolver | undefined;
+    get deleteMany(): OpraSchema.DeleteManyMethodResolver | undefined;
+    get get(): OpraSchema.GetMethodResolver | undefined;
+    get update(): OpraSchema.UpdateMethodResolver | undefined;
+    get updateMany(): OpraSchema.UpdateManyMethodResolver | undefined;
+    get search(): OpraSchema.SearchMethodResolver | undefined;
+    getSchema(jsonOnly?: boolean): OpraSchema.CollectionResource;
+}

package/typings/common/schema/implementation/resource/container-resource-info.d.ts

@@ -0,0 +1,13 @@
+import { IResourceContainer } from '../../interfaces/resource-container.interface.js';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import type { OpraDocument } from '../opra-document.js';
+import { CollectionResourceInfo } from './collection-resource-info.js';
+import { ResourceInfo } from './resource-info.js';
+import { SingletonResourceInfo } from './singleton-resource-info.js';
+export declare class ContainerResourceInfo extends ResourceInfo implements IResourceContainer {
+    readonly metadata: OpraSchema.ContainerResource;
+    constructor(service: OpraDocument, name: string, metadata: OpraSchema.ContainerResource);
+    getResource<T extends ResourceInfo>(name: string): T;
+    getCollectionResource(name: string): CollectionResourceInfo;
+    getSingletonResource(name: string): SingletonResourceInfo;
+}

package/typings/common/schema/implementation/resource/resource-info.d.ts

@@ -0,0 +1,17 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { nodeInspectCustom } from '../../utils/inspect.util.js';
+import type { OpraDocument } from '../opra-document.js';
+export declare abstract class ResourceInfo {
+    readonly metadata: OpraSchema.Resource;
+    readonly document: OpraDocument;
+    readonly name: string;
+    protected path: string;
+    protected constructor(document: OpraDocument, name: string, metadata: OpraSchema.Resource);
+    get instance(): {} | undefined;
+    get kind(): OpraSchema.ResourceKind;
+    get description(): string | undefined;
+    toString(): string;
+    validateQueryOptions(): any;
+    getSchema(jsonOnly?: boolean): OpraSchema.Resource;
+    [nodeInspectCustom](): string;
+}

package/typings/common/schema/implementation/resource/singleton-resource-info.d.ts

@@ -0,0 +1,14 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import type { OpraDocument } from '../opra-document.js';
+import { ResourceInfo } from './resource-info.js';
+export declare class SingletonResourceInfo extends ResourceInfo {
+    readonly metadata: OpraSchema.SingletonResource;
+    readonly dataType: ComplexType;
+    constructor(document: OpraDocument, name: string, dataType: ComplexType, metadata: OpraSchema.SingletonResource);
+    get create(): OpraSchema.CreateMethodResolver | undefined;
+    get delete(): OpraSchema.MethodResolver | undefined;
+    get get(): OpraSchema.GetMethodResolver | undefined;
+    get update(): OpraSchema.UpdateMethodResolver | undefined;
+    getSchema(jsonOnly?: boolean): OpraSchema.SingletonResource;
+}

package/typings/common/schema/implementation/schema-builder/extract-resource-metadata.util.d.ts

@@ -0,0 +1,3 @@
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { Named } from '../../types.js';
+export declare function extractResourceSchema(instance: object): Promise<Named<OpraSchema.Resource>>;

package/typings/common/schema/implementation/schema-builder/extract-type-metadata.util.d.ts

@@ -0,0 +1,4 @@
+import { Type } from 'ts-gems';
+import { OpraSchema } from '../../opra-schema.definition.js';
+import { Named } from '../../types.js';
+export declare function extractDataTypeSchema(ctor: Type | Function): Promise<Named<OpraSchema.DataType>>;

package/typings/common/schema/index.d.ts

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+export * from './constants.js';
+export * from './types.js';
+export * from './opra-schema.definition.js';
+export * from './decorators/opr-complex-type.decorator.js';
+export * from './decorators/opr-field.decorator.js';
+export * from './decorators/opr-collection-resource.decorator.js';
+export * from './decorators/opr-singleton-resource.decorator.js';
+export * from './decorators/opr-resolver.decorator.js';
+export * from './interfaces/resource-container.interface.js';
+export * from './implementation/document-builder.js';
+export * from './implementation/opra-document.js';
+export * from './implementation/data-type/data-type.js';
+export * from './implementation/data-type/complex-type.js';
+export * from './implementation/data-type/simple-type.js';
+export * from './implementation/data-type/union-type.js';
+export * from './implementation/resource/resource-info.js';
+export * from './implementation/resource/container-resource-info.js';
+export * from './implementation/resource/collection-resource-info.js';
+export * from './implementation/resource/singleton-resource-info.js';
+export * from './implementation/query/index.js';
+export * from './type-helpers/mixin-type.helper.js';
+export * from './type-helpers/extend-type.helper.js';
+export * from './implementation/schema-builder/extract-type-metadata.util.js';
+export * from './implementation/schema-builder/extract-resource-metadata.util.js';

package/typings/common/schema/interfaces/child-field-query.interface.d.ts

@@ -0,0 +1,4 @@
+import type { FieldGetQueryOptions } from '../implementation/query/index.js';
+export interface IChildFieldQuery {
+    child?: FieldGetQueryOptions;
+}

package/typings/common/schema/interfaces/data-type.metadata.d.ts

@@ -0,0 +1,18 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../opra-schema.definition.js';
+import { TypeThunkAsync } from '../types.js';
+export declare type SimpleTypeMetadata = OpraSchema.SimpleType & {
+    name: string;
+};
+export declare type ComplexTypeMetadata = StrictOmit<OpraSchema.ComplexType, 'fields' | 'extends'> & {
+    name: string;
+    extends?: ComplexTypeExtendingMetadata[];
+    fields?: Record<string, FieldMetadata>;
+};
+export declare type FieldMetadata = StrictOmit<OpraSchema.Field, 'type'> & {
+    type?: string | TypeThunkAsync | (string | TypeThunkAsync)[];
+};
+declare type ComplexTypeExtendingMetadata = StrictOmit<OpraSchema.ComplexTypeExtendingInfo, 'type'> & {
+    type: string | Type;
+};
+export {};

package/typings/common/schema/interfaces/resource-container.interface.d.ts

@@ -0,0 +1,8 @@
+import { CollectionResourceInfo } from '../implementation/resource/collection-resource-info.js';
+import { ResourceInfo } from '../implementation/resource/resource-info.js';
+import { SingletonResourceInfo } from '../implementation/resource/singleton-resource-info.js';
+export interface IResourceContainer {
+    getResource<T extends ResourceInfo>(name: string): T;
+    getCollectionResource(name: string): CollectionResourceInfo;
+    getSingletonResource(name: string): SingletonResourceInfo;
+}

package/typings/common/schema/interfaces/resource.metadata.d.ts

@@ -0,0 +1,18 @@
+import { PartialSome, StrictOmit } from 'ts-gems';
+import { OpraSchema } from '../opra-schema.definition.js';
+import { TypeThunkAsync } from '../types.js';
+export declare type CollectionResourceMetadata = PartialSome<StrictOmit<OpraSchema.CollectionResource, 'type'>, 'keyFields'> & {
+    type: TypeThunkAsync | string;
+    name: string;
+};
+export declare type SingletonResourceMetadata = StrictOmit<OpraSchema.SingletonResource, 'type'> & {
+    type: TypeThunkAsync | string;
+    name: string;
+};
+export declare type ICreateResolverMetadata = StrictOmit<OpraSchema.CreateMethodResolver, 'handler'>;
+export declare type IDeleteResolverMetadata = StrictOmit<OpraSchema.DeleteMethodResolver, 'handler'>;
+export declare type IDeleteManyResolverMetadata = StrictOmit<OpraSchema.DeleteManyMethodResolver, 'handler'>;
+export declare type IGetResolverMetadata = StrictOmit<OpraSchema.GetMethodResolver, 'handler'>;
+export declare type IUpdateResolverMetadata = StrictOmit<OpraSchema.UpdateMethodResolver, 'handler'>;
+export declare type IUpdateManyResolverMetadata = StrictOmit<OpraSchema.UpdateManyMethodResolver, 'handler'>;
+export declare type ISearchResolverMetadata = StrictOmit<OpraSchema.SearchMethodResolver, 'handler'>;