@opra/common 0.22.0 → 0.23.1

package/types/document/resource/resource.d.ts

@@ -16,6 +16,7 @@ export declare abstract class Resource {
     readonly name: string;
     readonly description?: string;
     readonly controller?: object | Type;
+    abstract readonly operations: Record<string, any>;
     protected constructor(document: ApiDocument, init: Resource.InitArguments);
     exportSchema(): OpraSchema.ResourceBase;
     toString(): string;

package/types/document/resource/singleton.d.ts

@@ -1,51 +1,54 @@
 import { StrictOmit, Type } from 'ts-gems';
+import * as vg from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import type { TypeThunkAsync } from '../../types.js';
 import type { ApiDocument } from '../api-document.js';
 import { ComplexType } from '../data-type/complex-type.js';
 import { Resource } from './resource.js';
 export declare namespace Singleton {
-    export interface InitArguments extends Resource.InitArguments, Pick<OpraSchema.Singleton, 'operations'> {
+    interface InitArguments extends Resource.InitArguments, StrictOmit<OpraSchema.Singleton, 'kind' | 'type'> {
         type: ComplexType;
     }
-    export interface DecoratorOptions extends Resource.DecoratorOptions {
+    interface DecoratorOptions extends Resource.DecoratorOptions {
     }
-    export interface Metadata extends StrictOmit<OpraSchema.Singleton, 'type'> {
+    interface Metadata extends StrictOmit<OpraSchema.Singleton, 'type'> {
         name: string;
         type: TypeThunkAsync | string;
     }
-    interface Operation {
-        handlerName?: string;
+    namespace Create {
     }
-    export interface Operations {
-        create?: OpraSchema.Singleton.CreateOperation & Operation;
-        delete?: OpraSchema.Singleton.DeleteOperation & Operation;
-        get?: OpraSchema.Singleton.GetOperation & Operation;
-        update?: OpraSchema.Singleton.UpdateOperation & Operation;
+    namespace Delete {
     }
-    export type CreateOperationOptions = StrictOmit<OpraSchema.Singleton.CreateOperation, 'handler'>;
-    export type DeleteOperationOptions = StrictOmit<OpraSchema.Singleton.DeleteOperation, 'handler'>;
-    export type GetOperationOptions = StrictOmit<OpraSchema.Singleton.GetOperation, 'handler'>;
-    export type UpdateOperationOptions = StrictOmit<OpraSchema.Singleton.UpdateOperation, 'handler'>;
-    export {};
+    namespace Get {
+    }
+    namespace Update {
+    }
+    type CreateOperationOptions = OpraSchema.Singleton.CreateOperation;
+    type DeleteOperationOptions = OpraSchema.Singleton.DeleteOperation;
+    type GetOperationOptions = OpraSchema.Singleton.GetOperation;
+    type UpdateOperationOptions = OpraSchema.Singleton.UpdateOperation;
 }
 declare class SingletonClass extends Resource {
+    private _decoders;
+    private _encoders;
     readonly type: ComplexType;
     readonly kind = "Singleton";
-    readonly operations: Singleton.Operations;
+    readonly operations: OpraSchema.Singleton.Operations;
     readonly controller?: object | Type;
     constructor(document: ApiDocument, init: Singleton.InitArguments);
     exportSchema(): OpraSchema.Singleton;
-    normalizeFieldPath(this: Singleton, path: string | []): string | string[];
+    normalizeFieldPath(this: Singleton, path: string | string[]): string[] | undefined;
+    getDecoder(operation: keyof OpraSchema.Singleton.Operations): vg.Validator<any, any>;
+    getEncoder(operation: keyof OpraSchema.Singleton.Operations): vg.Validator<any, any>;
 }
 export interface SingletonConstructor {
     prototype: Singleton;
     new (document: ApiDocument, init: Singleton.InitArguments): Singleton;
     (type: TypeThunkAsync | string, options?: Singleton.DecoratorOptions): ClassDecorator;
-    Create: (options?: Singleton.CreateOperationOptions) => PropertyDecorator;
-    Delete: (options?: Singleton.DeleteOperationOptions) => PropertyDecorator;
-    Get: (options?: Singleton.GetOperationOptions) => PropertyDecorator;
-    Update: (options?: Singleton.UpdateOperationOptions) => PropertyDecorator;
+    Create: (options?: Singleton.CreateOperationOptions) => ((target: Object, propertyKey: 'create') => void);
+    Delete: (options?: Singleton.DeleteOperationOptions) => ((target: Object, propertyKey: 'delete') => void);
+    Get: (options?: Singleton.GetOperationOptions) => ((target: Object, propertyKey: 'get') => void);
+    Update: (options?: Singleton.UpdateOperationOptions) => ((target: Object, propertyKey: 'update') => void);
 }
 export interface Singleton extends SingletonClass {
 }

package/types/document/resource/storage.d.ts

@@ -3,29 +3,26 @@ import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
 import { Resource } from './resource.js';
 export declare namespace Storage {
-    export interface InitArguments extends Resource.InitArguments, Pick<OpraSchema.Storage, 'operations'> {
+    interface InitArguments extends Resource.InitArguments, StrictOmit<OpraSchema.Storage, 'kind'> {
     }
-    export interface DecoratorOptions extends Resource.DecoratorOptions {
+    interface DecoratorOptions extends Resource.DecoratorOptions {
     }
-    export interface Metadata extends OpraSchema.Storage {
+    interface Metadata extends OpraSchema.Storage {
         name: string;
     }
-    interface Operation {
-        handlerName?: string;
+    namespace Delete {
     }
-    export interface Operations {
-        delete?: OpraSchema.Storage.DeleteOperation & Operation;
-        get?: OpraSchema.Storage.GetOperation & Operation;
-        put?: OpraSchema.Storage.PutOperation & Operation;
+    namespace Get {
     }
-    export type DeleteOperationOptions = StrictOmit<OpraSchema.Storage.DeleteOperation, 'handler'>;
-    export type GetOperationOptions = StrictOmit<OpraSchema.Storage.GetOperation, 'handler'>;
-    export type PutOperationOptions = StrictOmit<OpraSchema.Storage.PutOperation, 'handler'>;
-    export {};
+    namespace Post {
+    }
+    type DeleteOperationOptions = OpraSchema.Storage.DeleteOperation;
+    type GetOperationOptions = OpraSchema.Storage.GetOperation;
+    type PostOperationOptions = OpraSchema.Storage.PostOperation;
 }
 declare class StorageClass extends Resource {
     readonly kind = "Storage";
-    readonly operations: Storage.Operations;
+    readonly operations: OpraSchema.Storage.Operations;
     readonly controller?: object | Type;
     constructor(document: ApiDocument, init: Storage.InitArguments);
     exportSchema(): OpraSchema.Storage;
@@ -34,9 +31,9 @@ export interface StorageConstructor {
     prototype: Storage;
     new (document: ApiDocument, init: Storage.InitArguments): Storage;
     (options?: Storage.DecoratorOptions): ClassDecorator;
-    Delete: (options?: Storage.DeleteOperationOptions) => PropertyDecorator;
-    Get: (options?: Storage.GetOperationOptions) => PropertyDecorator;
-    Put: (options?: Storage.PutOperationOptions) => PropertyDecorator;
+    Delete: (options?: Storage.DeleteOperationOptions) => ((target: Object, propertyKey: 'delete') => void);
+    Get: (options?: Storage.GetOperationOptions) => ((target: Object, propertyKey: 'get') => void);
+    Post: (options?: Storage.PostOperationOptions) => ((target: Object, propertyKey: 'post') => void);
 }
 export interface Storage extends StorageClass {
 }

package/types/document/utils/generate-codec.d.ts

@@ -0,0 +1,10 @@
+import * as vg from 'valgen';
+import { ComplexType } from '../data-type/complex-type.js';
+import { MappedType } from '../data-type/mapped-type.js';
+import { UnionType } from '../data-type/union-type.js';
+export interface GenerateDecoderOptions {
+    omit?: string[];
+    partial?: boolean;
+}
+export declare function generateCodec(type: ComplexType, codec: 'decode' | 'encode', options: GenerateDecoderOptions): vg.Validator<any, any>;
+export declare function _generateDecoder(type: ComplexType | MappedType | UnionType, codec: 'decode' | 'encode', options: GenerateDecoderOptions): vg.Validator<any, any>;

package/types/exception/error-issue.d.ts

@@ -2,8 +2,9 @@ import { IssueSeverity } from './issue-severity.enum.js';
 export interface ErrorIssue {
     message: string;
     severity: IssueSeverity.Type;
+    system?: string;
     code?: string;
     details?: any;
     diagnostics?: string | string[];
-    debugInfo?: string;
+    stack?: string[];
 }

package/types/exception/http-errors/bad-request.error.d.ts

@@ -1,3 +1,4 @@
+import { ErrorIssue } from '../error-issue.js';
 import { OpraException } from '../opra-exception.js';
 /**
  * 400 Bad Request
@@ -6,5 +7,5 @@ import { OpraException } from '../opra-exception.js';
  */
 export declare class BadRequestError extends OpraException {
     status: number;
-    setIssue(issue: any): void;
+    protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/failed-dependency.error.d.ts

@@ -1,3 +1,4 @@
+import { ErrorIssue } from '../error-issue.js';
 import { OpraException } from '../opra-exception.js';
 /**
  * 424 Failed Dependency
@@ -5,5 +6,5 @@ import { OpraException } from '../opra-exception.js';
  */
 export declare class FailedDependencyError extends OpraException {
     status: number;
-    setIssue(issue: any): void;
+    protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/forbidden.error.d.ts

@@ -1,3 +1,4 @@
+import { ErrorIssue } from '../error-issue.js';
 import { OpraException } from '../opra-exception.js';
 /**
  * 403 Forbidden
@@ -7,5 +8,5 @@ import { OpraException } from '../opra-exception.js';
  */
 export declare class ForbiddenError extends OpraException {
     status: number;
-    setIssue(issue: any): void;
+    protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/internal-server.error.d.ts

@@ -1,3 +1,4 @@
+import { ErrorIssue } from '../error-issue.js';
 import { OpraException } from '../opra-exception.js';
 /**
  * 500 Internal Server Error
@@ -5,5 +6,5 @@ import { OpraException } from '../opra-exception.js';
  */
 export declare class InternalServerError extends OpraException {
     status: number;
-    setIssue(issue: any): void;
+    protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/method-not-allowed.error.d.ts

@@ -1,3 +1,4 @@
+import { ErrorIssue } from '../error-issue.js';
 import { OpraException } from '../opra-exception.js';
 /**
  * 405 Method Not Allowed
@@ -6,5 +7,5 @@ import { OpraException } from '../opra-exception.js';
  */
 export declare class MethodNotAllowedError extends OpraException {
     status: number;
-    setIssue(issue: any): void;
+    protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/not-acceptable.error.d.ts

@@ -1,3 +1,4 @@
+import { ErrorIssue } from '../error-issue.js';
 import { OpraException } from '../opra-exception.js';
 /**
  * 406 Not Acceptable
@@ -6,5 +7,5 @@ import { OpraException } from '../opra-exception.js';
  */
 export declare class NotAcceptableError extends OpraException {
     status: number;
-    setIssue(issue: any): void;
+    protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/not-found.error.d.ts

@@ -1,3 +1,4 @@
+import { ErrorIssue } from '../error-issue.js';
 import { OpraException } from '../opra-exception.js';
 /**
  * 404 Not Found
@@ -9,5 +10,5 @@ import { OpraException } from '../opra-exception.js';
  */
 export declare class NotFoundError extends OpraException {
     status: number;
-    setIssue(issue: any): void;
+    protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/unauthorized.error.d.ts

@@ -1,3 +1,4 @@
+import { ErrorIssue } from '../error-issue.js';
 import { OpraException } from '../opra-exception.js';
 /**
  * 401 Unauthorized
@@ -6,5 +7,5 @@ import { OpraException } from '../opra-exception.js';
  */
 export declare class UnauthorizedError extends OpraException {
     status: number;
-    setIssue(issue: any): void;
+    protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/http-errors/unprocessable-entity.error.d.ts

@@ -1,3 +1,4 @@
+import { ErrorIssue } from '../error-issue.js';
 import { OpraException } from '../opra-exception.js';
 /**
  * 422 Unprocessable Entity
@@ -5,5 +6,5 @@ import { OpraException } from '../opra-exception.js';
  */
 export declare class UnprocessableEntityError extends OpraException {
     status: number;
-    setIssue(issue: any): void;
+    protected init(issue: Partial<ErrorIssue>): void;
 }

package/types/exception/opra-exception.d.ts

@@ -1,17 +1,22 @@
 import { ErrorIssue } from './error-issue.js';
+import { IssueSeverity } from './issue-severity.enum.js';
 /**
  * Defines the base Opra exception, which is handled by the default Exceptions Handler.
  */
 export declare class OpraException extends Error {
-    protected _issue: ErrorIssue;
-    status: number;
     cause?: Error;
+    status: number;
+    severity: IssueSeverity.Type;
+    system?: string;
+    code?: string;
+    details?: any;
     constructor();
-    constructor(issue: string | Partial<ErrorIssue> | Error);
-    constructor(issue: string | Partial<ErrorIssue>, cause?: Error);
-    get issue(): ErrorIssue;
-    setIssue(issue: Partial<ErrorIssue>): void;
+    constructor(issue: string | Partial<ErrorIssue> | Error, status?: number);
+    constructor(issue: string | Partial<ErrorIssue>, cause?: Error, status?: number);
     setStatus(status: number): this;
-    protected _initName(): void;
-    protected _init(issue: any): void;
+    toString(): string;
+    toJSON(): ErrorIssue;
+    protected init(issue: Partial<ErrorIssue>): void;
+    protected initString(issue: string): void;
+    protected initError(issue: Error): void;
 }

package/types/exception/wrap-exception.d.ts

@@ -1,2 +1,2 @@
 import { OpraException } from './opra-exception.js';
-export declare function wrapException(e: any): OpraException;
+export declare function wrapException(error: any): OpraException;

package/types/helpers/index.d.ts

@@ -1,6 +1,6 @@
 export * from './function-utils.js';
 export * from './get-stack-filename.js';
-export * from './is-url.js';
+export * from './is-url-string.js';
 export * from './mixin-utils.js';
 export * from './object-utils.js';
 export * from './path-to-object-tree.js';

package/types/helpers/is-url-string.d.ts

@@ -0,0 +1,2 @@
+export declare function isUrlString(url: string): boolean;
+export declare const isAbsoluteUrl: (urlString: string) => boolean;

package/types/helpers/object-utils.d.ts

@@ -1,2 +1,2 @@
 export declare function cloneObject<T extends {}>(obj: T, jsonOnly?: boolean): T;
-export declare function omitUndefined(obj: any): any;
+export declare function omitUndefined<T>(obj: T, recursive?: boolean): T;

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

@@ -5,7 +5,10 @@ import { Type } from 'ts-gems';
 export declare function isConstructor(fn: any): fn is Type;
 export declare function isStream(stream: any): boolean;
 export declare function isReadable(x: any): x is Readable;
+export declare function isWritable(x: any): x is Readable;
 export declare function isReadableStream(x: any): x is ReadableStream;
 export declare function isBlob(x: any): x is Blob;
 export declare function isFormData(x: any): x is FormData;
 export declare function isURL(x: any): x is URL;
+export declare function isIterable<T = unknown>(x: any): x is Iterable<T>;
+export declare function isAsyncIterable<T = unknown>(x: any): x is AsyncIterableIterator<T>;

package/types/http/index.d.ts

@@ -1,12 +1,5 @@
-export * from './http-params.js';
+export * from './opra-url.js';
+export * from './opra-url-path.js';
 export * from './enums/http-headers-codes.enum.js';
 export * from './enums/http-status-codes.enum.js';
 export * from './enums/http-status-messages.js';
-export * from './interfaces/client-http-headers.interface.js';
-export * from './interfaces/server-http-headers.interface.js';
-export * from './codecs/date-codec.js';
-export * from './codecs/boolean-codec.js';
-export * from './codecs/filter-codec.js';
-export * from './codecs/integer-codec.js';
-export * from './codecs/number-codec.js';
-export * from './codecs/string-codec.js';

package/types/http/opra-url-path.d.ts

@@ -0,0 +1,54 @@
+declare const nodeInspectCustom: unique symbol;
+declare const kLength: unique symbol;
+type ResourceKey = Record<string, string | number | boolean | null>;
+/**
+ * @class OpraURLPath
+ */
+export declare class OpraURLPath {
+    protected [kLength]: number;
+    [index: number]: OpraURLPathComponent;
+    constructor(...init: (OpraURLPath.ComponentLike | null | undefined)[]);
+    get length(): number;
+    resolve(...items: OpraURLPath.ComponentLike[]): this;
+    join(...items: OpraURLPath.ComponentLike[]): OpraURLPath;
+    isRelativeTo(basePath: string | OpraURLPath): boolean;
+    forEach(callback: (component: OpraURLPathComponent, index: number, _this: this) => void): void;
+    values(): IterableIterator<OpraURLPathComponent>;
+    toString(): string;
+    [nodeInspectCustom](): string;
+    [Symbol.iterator](): IterableIterator<OpraURLPathComponent>;
+    protected _resolve(items: OpraURLPath.ComponentLike | OpraURLPath.ComponentLike[], join?: boolean): void;
+    static join(...items: OpraURLPath.ComponentLike[]): OpraURLPath;
+    static resolve(...items: OpraURLPath.ComponentLike[]): OpraURLPath;
+    static relative(source: string | OpraURLPath, basePath: string | OpraURLPath): OpraURLPath | undefined;
+}
+export declare namespace OpraURLPath {
+    type ComponentLike = string | OpraURLPath | OpraURLPathComponent | OpraURLPathComponent.Initiator;
+}
+/**
+ *
+ * @class OpraURLPathComponent
+ */
+declare class OpraURLPathComponent {
+    resource: string;
+    key?: string | number | ResourceKey;
+    args?: Record<string, any>;
+    typeCast?: string;
+    constructor(init: OpraURLPathComponent.Initiator);
+    toString(): string;
+    [nodeInspectCustom](): string;
+    /**
+     * Factory method.
+     * @param input
+     */
+    static parse(input: string): OpraURLPathComponent;
+}
+export declare namespace OpraURLPathComponent {
+    interface Initiator {
+        resource: string;
+        key?: string | number | ResourceKey;
+        args?: Record<string, any>;
+        typeCast?: string;
+    }
+}
+export {};

package/types/{url → http}/opra-url.d.ts

@@ -1,26 +1,22 @@
-import { HttpParams } from '../http/index.js';
 import { OpraURLPath } from './opra-url-path.js';
-import { OpraURLPathComponentInit } from './opra-url-path-component.js';
 declare const nodeInspectCustom: unique symbol;
 declare const kContext: unique symbol;
 declare const kPath: unique symbol;
-declare const kParams: unique symbol;
+declare const kSearchParams: unique symbol;
 export declare class OpraURL {
     protected static kContext: symbol;
     protected static kPath: symbol;
     protected static kParams: symbol;
     protected [kPath]: OpraURLPath;
-    protected [kParams]: HttpParams;
+    protected [kSearchParams]: URLSearchParams;
     protected [kContext]: {
         protocol: string;
         username: string;
         pathname?: string;
-        prefix: string;
         hostname: string;
         port: string;
         hash: string;
         password: string;
-        search?: string;
         address?: string;
     };
     constructor(input?: string | URL | OpraURL, base?: string | URL | OpraURL);
@@ -34,24 +30,26 @@ export declare class OpraURL {
     set password(v: string);
     get port(): string;
     set port(value: string | number);
-    get prefix(): string;
-    set prefix(value: string);
     get protocol(): string;
     set protocol(v: string);
     get username(): string;
     set username(v: string);
     get origin(): string;
     get path(): OpraURLPath;
+    set path(path: OpraURLPath);
     get pathname(): string;
     set pathname(v: string);
     get hash(): string;
     set hash(v: string);
     get search(): string;
     set search(v: string);
-    get searchParams(): HttpParams;
-    parse(input: string): void;
-    join(...source: (string | OpraURLPath | URL | OpraURL | OpraURLPathComponentInit)[]): this;
+    get searchParams(): URLSearchParams;
+    set setSearchParams(v: URLSearchParams);
+    invalidate(): void;
+    join(...items: OpraURLPath.ComponentLike[]): this;
+    resolve(...items: OpraURLPath.ComponentLike[]): OpraURL;
     toString(): string;
+    protected _parse(input: string): void;
     [nodeInspectCustom](): {
         protocol: string;
         username: string;
@@ -59,12 +57,10 @@ export declare class OpraURL {
         host: string;
         hostname: string;
         origin: string;
-        pathPrefix: string;
         path: OpraURLPath;
         pathname: string;
         search: string;
         hash: string;
     };
-    protected _setPathname(v: string, trimPrefix?: boolean): void;
 }
 export {};

package/types/index.d.ts

@@ -6,6 +6,4 @@ export * from './helpers/index.js';
 export * from './http/index.js';
 export * from './i18n/index.js';
 export * from './schema/index.js';
-export * from './url/index.js';
-export * from './utils/path-utils.js';
 export { uid } from 'uid';

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

@@ -8,7 +8,7 @@ export interface ComplexType extends DataTypeBase {
     base?: DataType.Name | ComplexType | UnionType | MappedType;
     abstract?: boolean;
     fields?: Record<Field.Name, Field | DataType.Name>;
-    additionalFields?: boolean;
+    additionalFields?: boolean | 'error';
 }
 export declare namespace ComplexType {
     const Kind = "ComplexType";

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

@@ -7,7 +7,7 @@ export * from './data-type/mapped-type.interface.js';
 export * from './data-type/union-type.interface.js';
 export * from './resource/collection.interface.js';
 export * from './resource/container.interface.js';
-export * from './resource/endpoint.interface.js';
+export * from './resource/operation.interface.js';
 export * from './resource/resource.interface.js';
 export * from './resource/singleton.interface.js';
 export * from './resource/storage.interface.js';

package/types/schema/resource/collection.interface.d.ts

@@ -1,6 +1,7 @@
+import type { OpraFilter } from '../../filter/index.js';
 import type { DataType } from '../data-type/data-type.interface.js';
 import type { Field } from '../data-type/field.interface';
-import type { _Operation, Endpoint } from './endpoint.interface.js';
+import type { Operation } from './operation.interface';
 import type { ResourceBase } from './resource.interface.js';
 export interface Collection extends ResourceBase {
     kind: Collection.Kind;
@@ -11,16 +12,16 @@ export interface Collection extends ResourceBase {
 export declare namespace Collection {
     const Kind = "Collection";
     type Kind = 'Collection';
-    type CreateOperation = Endpoint & _Operation.InputPickOmit & _Operation.ResponsePickOmit;
-    type DeleteOperation = Endpoint;
-    type DeleteManyOperation = Endpoint & _Operation.Filter;
-    type GetOperation = Endpoint & _Operation.ResponsePickOmit;
-    type FindManyOperation = Endpoint & _Operation.Filter & _Operation.ResponsePickOmit & {
+    type CreateOperation = Operation & _OperationInput & _OperationResponse;
+    type DeleteOperation = Operation;
+    type DeleteManyOperation = Operation & _OperationFilter;
+    type GetOperation = Operation & _OperationResponse;
+    type FindManyOperation = Operation & _OperationFilter & _OperationResponse & {
         sortFields?: string[];
         defaultSort?: string[];
     };
-    type UpdateOperation = Endpoint & _Operation.InputPickOmit & _Operation.ResponsePickOmit;
-    type UpdateManyOperation = Endpoint & _Operation.InputPickOmit & _Operation.Filter;
+    type UpdateOperation = Operation & _OperationInput & _OperationResponse;
+    type UpdateManyOperation = Operation & _OperationInput & _OperationFilter;
     interface Operations {
         create?: CreateOperation;
         delete?: DeleteOperation;
@@ -31,3 +32,23 @@ export declare namespace Collection {
         updateMany?: UpdateManyOperation;
     }
 }
+interface _OperationFilter {
+    filters?: {
+        field: Field.QualifiedName;
+        operators?: OpraFilter.ComparisonOperator[];
+    }[];
+}
+interface _OperationInput {
+    input?: {
+        maxContentSize?: number | string;
+        pick?: Field.QualifiedName[];
+        omit?: Field.QualifiedName[];
+    };
+}
+interface _OperationResponse {
+    response?: {
+        pick?: Field.QualifiedName[];
+        omit?: Field.QualifiedName[];
+    };
+}
+export {};

package/types/schema/resource/operation.interface.d.ts

@@ -0,0 +1,3 @@
+export interface Operation {
+    description?: string;
+}

package/types/schema/resource/singleton.interface.d.ts

@@ -1,5 +1,5 @@
 import type { DataType } from '../data-type/data-type.interface.js';
-import type { _Operation, Endpoint } from './endpoint.interface.js';
+import type { Collection } from './collection.interface.js';
 import type { ResourceBase } from './resource.interface.js';
 export interface Singleton extends ResourceBase {
     kind: Singleton.Kind;
@@ -9,10 +9,10 @@ export interface Singleton extends ResourceBase {
 export declare namespace Singleton {
     const Kind = "Singleton";
     type Kind = 'Singleton';
-    type CreateOperation = Endpoint & _Operation.InputPickOmit & _Operation.ResponsePickOmit;
-    type DeleteOperation = Endpoint;
-    type GetOperation = Endpoint & _Operation.ResponsePickOmit;
-    type UpdateOperation = Endpoint & _Operation.InputPickOmit & _Operation.ResponsePickOmit;
+    type CreateOperation = Collection.CreateOperation;
+    type DeleteOperation = Collection.DeleteOperation;
+    type GetOperation = Collection.GetOperation;
+    type UpdateOperation = Collection.UpdateOperation;
     interface Operations {
         create?: CreateOperation;
         delete?: DeleteOperation;