@opra/common 0.33.13 → 1.0.0-alpha.1

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

@@ -1,62 +0,0 @@
-import { Combine, StrictOmit } from 'ts-gems';
-import type { ApiDocument } from '../api-document.js';
-import { ComplexType } from '../data-type/complex-type.js';
-import { CollectionClass } from './collection-class.js';
-import { CollectionDecorator } from './collection-decorator.js';
-import type { Container } from './container.js';
-import { Resource } from './resource.js';
-export interface Collection extends CollectionClass {
-}
-export interface CollectionConstructor extends CollectionDecorator {
-    prototype: CollectionClass;
-    new (parent: ApiDocument | Container, init: Collection.InitArguments): CollectionClass;
-}
-/**
- * @class Collection
- * @decorator Collection
- */
-export declare const Collection: CollectionConstructor;
-/**
- * @namespace Collection
- */
-export declare namespace Collection {
-    interface InitArguments extends StrictOmit<Combine<Resource.InitArguments, CollectionDecorator.Metadata>, 'kind' | 'type'> {
-        name: string;
-        type: ComplexType;
-    }
-    interface DecoratorOptions<T = any> extends Partial<StrictOmit<CollectionDecorator.Metadata, 'kind' | 'operations' | 'actions' | 'primaryKey'>> {
-        primaryKey?: keyof T | (keyof T)[];
-    }
-    interface Action {
-    }
-    namespace Action {
-    }
-    interface Create {
-    }
-    namespace Create {
-    }
-    interface Delete {
-    }
-    namespace Delete {
-    }
-    interface DeleteMany {
-    }
-    namespace DeleteMany {
-    }
-    interface FindMany {
-    }
-    namespace FindMany {
-    }
-    interface Get {
-    }
-    namespace Get {
-    }
-    interface Update {
-    }
-    namespace Update {
-    }
-    interface UpdateMany {
-    }
-    namespace UpdateMany {
-    }
-}

package/types/document/resource/container-class.d.ts

@@ -1,66 +0,0 @@
-import { ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import type { Collection } from './collection.js';
-import type { Container } from './container.js';
-import { Resource } from './resource.js';
-import { Singleton } from './singleton.js';
-import { Storage } from './storage.js';
-export declare class ContainerClass extends Resource {
-    readonly kind: OpraSchema.Resource.Kind;
-    readonly resources: ResponsiveMap<Resource>;
-    readonly parent?: Container;
-    constructor(owner: ApiDocument | Container, init: Container.InitArguments);
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Container;
-    /**
-     * Returns Resource instance by path. Returns undefined if not found
-     * @param path
-     * @param silent
-     */
-    getResource(path: string, silent: boolean): Resource | undefined;
-    getResource(path: string, silent: true): Resource | undefined;
-    /**
-     * Returns Resource instance by path. Throws error if not found
-     * @param path
-     */
-    getResource(path: string): Resource;
-    getResource(path: string, silent: false): Resource;
-    /**
-     * Returns Collection resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getContainer(path: string): Container;
-    getContainer(path: string, silent: false): Container;
-    getContainer(path: string, silent: true): Container | undefined;
-    getContainer(path: string, silent?: boolean): Container | undefined;
-    /**
-     * Returns Collection resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getCollection(path: string): Collection;
-    getCollection(path: string, silent: false): Collection;
-    getCollection(path: string, silent: true): Collection | undefined;
-    getCollection(path: string, silent?: boolean): Collection | undefined;
-    /**
-     * Returns Singleton resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getSingleton(path: string): Singleton;
-    getSingleton(path: string, silent: false): Singleton;
-    getSingleton(path: string, silent: true): Singleton | undefined;
-    getSingleton(path: string, silent?: boolean): Singleton | undefined;
-    /**
-     * Returns Storage resource instance by path
-     * Returns undefined if not found
-     * Throws error if resource is not a Collection
-     */
-    getStorage(path: string): Storage;
-    getStorage(path: string, silent: false): Storage;
-    getStorage(path: string, silent: true): Storage | undefined;
-    getStorage(path: string, silent?: boolean): Storage | undefined;
-}

package/types/document/resource/container-decorator.d.ts

@@ -1,37 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import { ActionDecorator } from './action-decorator.js';
-import { CollectionDecorator } from './collection-decorator.js';
-import type { Container } from './container.js';
-import { ResourceDecorator } from './resource-decorator.js';
-export declare function ContainerDecorator(options?: Container.DecoratorOptions): ClassDecorator;
-export interface ContainerDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
-    (options?: Container.DecoratorOptions): ClassDecorator;
-    Action: (options?: CollectionDecorator.Action.Options) => ActionDecorator;
-}
-/**
- * @namespace CollectionDecorator
- */
-export declare namespace ContainerDecorator {
-    interface Metadata extends StrictOmit<OpraSchema.Container, 'kind' | 'actions' | 'resources'> {
-        kind: OpraSchema.Container.Kind;
-        name: string;
-        actions?: Record<string, ResourceDecorator.OperationMetadata>;
-        resources?: Type[];
-    }
-    /**
-     * @namespace Action
-     */
-    namespace Action {
-        interface Metadata extends ResourceDecorator.OperationMetadata {
-        }
-        interface Options extends ResourceDecorator.OperationOptions {
-        }
-    }
-}
-export declare namespace ContainerDecorator {
-    /**
-     * Action PropertyDecorator
-     */
-    function Action(options: ResourceDecorator.OperationOptions): ActionDecorator;
-}

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

@@ -1,27 +0,0 @@
-import { Combine, StrictOmit } from 'ts-gems';
-import type { ApiDocument } from '../api-document.js';
-import { ContainerClass } from './container-class.js';
-import { ContainerDecorator } from './container-decorator.js';
-import type { Resource } from './resource.js';
-export interface Container extends ContainerClass {
-}
-export interface ContainerConstructor extends ContainerDecorator {
-    prototype: ContainerClass;
-    new (parent: ApiDocument | Container, init: Container.InitArguments): ContainerClass;
-}
-/**
- * @class Container
- * @decorator Container
- */
-export declare const Container: ContainerConstructor;
-export declare namespace Container {
-    interface InitArguments extends StrictOmit<Combine<Resource.InitArguments, ContainerDecorator.Metadata>, 'kind' | 'resources'> {
-        resources?: Resource[];
-    }
-    interface DecoratorOptions extends Partial<StrictOmit<ContainerDecorator.Metadata, 'kind' | 'actions'>> {
-    }
-    interface Action {
-    }
-    namespace Action {
-    }
-}

package/types/document/resource/crud-operation-decorator.d.ts

@@ -1,6 +0,0 @@
-import { Type } from 'ts-gems';
-import { ResourceDecorator } from './resource-decorator.js';
-export type CrudOperationDecorator = ((target: Object, propertyKey: any) => void) & {
-    Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => CrudOperationDecorator;
-};
-export declare function createOperationDecorator<T extends CrudOperationDecorator, M extends ResourceDecorator.OperationMetadata>(operation: string, init: any, list: ((operationMeta: M, target: Object, propertyKey: string) => void)[]): T;

package/types/document/resource/crud-operation.d.ts

@@ -1,32 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { Validator } from 'valgen';
-import { OpraSchema } from '../../schema/index.js';
-import { DataType } from '../data-type/data-type.js';
-import { ApiField } from '../data-type/field.js';
-import { Endpoint } from './endpoint.js';
-import type { Resource } from './resource';
-import type { ResourceDecorator } from './resource-decorator.js';
-/**
- *
- * @class CrudOperation
- */
-export declare class CrudOperation extends Endpoint {
-    readonly resource: Resource;
-    readonly name: string;
-    readonly kind = "operation";
-    decodeInput: Validator;
-    returnType?: DataType;
-    encodeReturning: Validator;
-    inputOverwriteFields?: Record<string, ApiField.InitArguments>;
-    outputOverwriteFields?: Record<string, ApiField.InitArguments>;
-    constructor(resource: Resource, name: string, init: CrudOperation.InitArguments);
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Endpoint<any> & Record<string, any>;
-}
-export declare namespace CrudOperation {
-    interface InitArguments extends StrictOmit<ResourceDecorator.OperationMetadata, 'parameters'> {
-        parameters: Record<string, Endpoint.ParameterInit>;
-        returnType?: DataType;
-    }
-}

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

@@ -1,16 +0,0 @@
-import { ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import type { Container } from './container.js';
-import { CrudOperation } from './crud-operation.js';
-import { Resource } from './resource.js';
-export declare abstract class CrudResource extends Resource {
-    operations: ResponsiveMap<CrudOperation>;
-    protected constructor(parent: ApiDocument | Container, init: Resource.InitArguments);
-    getOperation(operation: string): CrudOperation | undefined;
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.ResourceBase & {
-        operations?: any;
-    };
-}

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

@@ -1,32 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { DataType } from '../data-type/data-type.js';
-import { Parameter } from './parameter.js';
-import type { Resource } from './resource';
-/**
- *
- * @class Endpoint
- */
-export declare abstract class Endpoint {
-    readonly resource: Resource;
-    readonly name: string;
-    abstract readonly kind: 'action' | 'operation';
-    description?: string;
-    parameters: ResponsiveMap<Parameter>;
-    options: any;
-    protected constructor(resource: Resource, name: string, init: Endpoint.InitArguments);
-    getFullPath(documentPath?: boolean): string;
-    defineParameter(name: string, init: Endpoint.ParameterInit): Parameter;
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Endpoint;
-}
-export declare namespace Endpoint {
-    interface InitArguments extends StrictOmit<OpraSchema.Endpoint, 'parameters'> {
-        parameters?: Record<string, ParameterInit>;
-    }
-    type ParameterInit = StrictOmit<Parameter.InitArguments, 'type'> & {
-        type?: DataType | string | Type;
-    };
-}

package/types/document/resource/enums/metadata-mode.enum.d.ts

@@ -1,5 +0,0 @@
-export declare enum MetadataMode {
-    'none' = "none",
-    'minimal' = "minimal",
-    'full' = "full"
-}

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

@@ -1,35 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { Validator } from 'valgen';
-import { OpraSchema } from '../../schema/index.js';
-import { DataType } from '../data-type/data-type.js';
-import type { ResourceDecorator } from './resource-decorator.js';
-/**
- *
- * @class Parameter
- */
-export declare class Parameter {
-    protected _decoder: Validator;
-    protected _encoder: Validator;
-    readonly name: string;
-    readonly type: DataType;
-    description?: string;
-    isArray?: boolean;
-    default?: any;
-    required?: boolean;
-    deprecated?: boolean | string;
-    examples?: any[] | Record<string, any>;
-    readonly isBuiltin?: boolean;
-    constructor(name: string, init: Parameter.InitArguments);
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Endpoint.Parameter;
-    getDecoder(): Validator;
-    getEncoder(): Validator;
-    generateCodec(codec: 'decode' | 'encode', options?: DataType.GenerateCodecOptions): Validator;
-}
-export declare namespace Parameter {
-    interface InitArguments extends StrictOmit<ResourceDecorator.ParameterMetadata, 'type'> {
-        type: DataType;
-        isBuiltin?: boolean;
-    }
-}

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

@@ -1,40 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import { TypeThunkAsync } from '../../types.js';
-import { EnumType } from '../data-type/enum-type.js';
-export interface ResourceDecorator {
-    Action: (options?: ResourceDecorator.OperationOptions) => ResourceDecorator;
-}
-export declare function ResourceDecorator<O extends ResourceDecorator.Options>(kind: OpraSchema.Resource.Kind, meta?: O): ClassDecorator;
-/**
- * @namespace ResourceDecorator
- */
-export declare namespace ResourceDecorator {
-    interface Metadata extends StrictOmit<OpraSchema.ResourceBase, 'actions'> {
-        name: string;
-        actions?: Record<string, ActionMetadata>;
-        operations?: Record<string, OperationMetadata>;
-    }
-    interface Options extends Partial<StrictOmit<Metadata, 'kind' | 'actions' | 'operations'>> {
-    }
-    interface ParameterMetadata extends StrictOmit<OpraSchema.Endpoint.Parameter, 'type'> {
-        type?: TypeThunkAsync | string;
-        enum?: EnumType.EnumObject | EnumType.EnumArray;
-    }
-    interface ParameterOptions extends Partial<ParameterMetadata> {
-    }
-    interface OperationMetadata extends StrictOmit<OpraSchema.Endpoint, 'parameters'> {
-        parameters: Record<string, ParameterMetadata>;
-    }
-    interface OperationOptions extends Partial<StrictOmit<OpraSchema.Endpoint, 'parameters'>> {
-        parameters?: Record<string, ParameterOptions>;
-    }
-    interface ActionMetadata extends StrictOmit<OpraSchema.Action, 'parameters' | 'returnType'> {
-        parameters: Record<string, ParameterMetadata>;
-        returnType?: TypeThunkAsync | string;
-    }
-    interface ActionOptions extends Partial<StrictOmit<OpraSchema.Action, 'parameters' | 'returnType'>> {
-        parameters?: Record<string, ParameterOptions>;
-        returnType?: TypeThunkAsync | string;
-    }
-}

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

@@ -1,35 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import { nodeInspectCustom } from '../utils/inspect.util.js';
-import { Action } from './action.js';
-import type { Container } from './container.js';
-import { CrudOperation } from './crud-operation.js';
-import type { ResourceDecorator } from './resource-decorator';
-export declare abstract class Resource {
-    readonly document: ApiDocument;
-    readonly parent?: Container;
-    abstract readonly kind: OpraSchema.Resource.Kind;
-    readonly name: string;
-    description?: string;
-    controller?: object;
-    ctor?: Type;
-    actions: ResponsiveMap<Action>;
-    protected constructor(parent: ApiDocument | Container, init: Resource.InitArguments);
-    getFullPath(documentPath?: boolean): string;
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.ResourceBase;
-    toString(): string;
-    [nodeInspectCustom](): string;
-}
-export declare namespace Resource {
-    interface InitArguments extends StrictOmit<ResourceDecorator.Metadata, 'kind' | 'operations' | 'actions'> {
-        name: string;
-        actions?: Record<string, Action.InitArguments>;
-        operations?: Record<string, CrudOperation.InitArguments>;
-        controller?: object;
-        ctor?: Type;
-    }
-}

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

@@ -1,21 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import type { ComplexType } from '../data-type/complex-type.js';
-import type { Container } from './container.js';
-import type { CrudOperation } from './crud-operation';
-import { CrudResource } from './crud-resource.js';
-import type { Singleton } from './singleton.js';
-import type { SingletonDecorator } from './singleton-decorator';
-export declare class SingletonClass extends CrudResource {
-    readonly kind: OpraSchema.Resource.Kind;
-    readonly type: ComplexType;
-    constructor(parent: ApiDocument | Container, init: Singleton.InitArguments);
-    getOperation(name: 'create'): (CrudOperation & Omit<SingletonDecorator.Create.Metadata, keyof CrudOperation>) | undefined;
-    getOperation(name: 'delete'): (CrudOperation & Omit<SingletonDecorator.Delete.Metadata, keyof CrudOperation>) | undefined;
-    getOperation(name: 'get'): (CrudOperation & Omit<SingletonDecorator.Get.Metadata, keyof CrudOperation>) | undefined;
-    getOperation(name: 'update'): (CrudOperation & Omit<SingletonDecorator.Update.Metadata, keyof CrudOperation>) | undefined;
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Singleton;
-    normalizeFieldNames(path: string | string[]): string[] | undefined;
-}

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

@@ -1,131 +0,0 @@
-import { Combine, StrictOmit, Type } from 'ts-gems';
-import { Field } from '../../schema/data-type/field.interface.js';
-import { OpraSchema } from '../../schema/index.js';
-import { TypeThunkAsync } from '../../types.js';
-import { ActionDecorator } from './action-decorator.js';
-import { CollectionDecorator } from './collection-decorator.js';
-import { ResourceDecorator } from './resource-decorator.js';
-import type { Singleton } from './singleton.js';
-type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
-declare const operationProperties: readonly ["create", "delete", "get", "update"];
-type OperationProperties = typeof operationProperties[number];
-export declare function SingletonDecorator(type: Type | string, options?: Singleton.DecoratorOptions): ClassDecorator;
-export interface SingletonDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
-    <T>(type: Type<T> | string, options?: Singleton.DecoratorOptions): ClassDecorator;
-    Action: (options?: SingletonDecorator.Action.Options) => (<T, K extends keyof T>(target: T, propertyKey: ErrorMessage<Exclude<K, OperationProperties>, `'${string & K}' property is reserved for operation endpoints and can not be used for actions`>) => void) & ActionDecorator;
-    Create: typeof SingletonDecorator.Create;
-    Delete: typeof SingletonDecorator.Delete;
-    Get: typeof SingletonDecorator.Get;
-    Update: typeof SingletonDecorator.Update;
-}
-/**
- * @namespace SingletonDecorator
- */
-export declare namespace SingletonDecorator {
-    interface Metadata extends StrictOmit<OpraSchema.Singleton, 'kind' | 'type' | 'operations' | 'actions'> {
-        kind: OpraSchema.Singleton.Kind;
-        name: string;
-        type: TypeThunkAsync | string;
-        actions?: Record<string, ResourceDecorator.OperationMetadata>;
-        operations?: {
-            create: Create.Metadata;
-            delete: Delete.Metadata;
-            get: Get.Metadata;
-            update: Update.Metadata;
-        };
-    }
-    /**
-     * @namespace Action
-     */
-    namespace Action {
-        interface Metadata extends ResourceDecorator.OperationMetadata {
-        }
-        interface Options extends ResourceDecorator.OperationOptions {
-        }
-    }
-    /**
-     * @namespace Create
-     */
-    namespace Create {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Singleton.Operations.Create> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Singleton.Operations.Create>> {
-        }
-    }
-    /**
-     * @namespace Delete
-     */
-    namespace Delete {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Singleton.Operations.Delete> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Singleton.Operations.Delete>> {
-        }
-    }
-    /**
-     * @namespace Get
-     */
-    namespace Get {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Singleton.Operations.Get> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Singleton.Operations.Get>> {
-        }
-    }
-    /**
-     * @namespace Update
-     */
-    namespace Update {
-        interface Metadata extends Combine<ResourceDecorator.OperationMetadata, OpraSchema.Singleton.Operations.Update> {
-        }
-        interface Options extends Combine<ResourceDecorator.OperationOptions, Partial<OpraSchema.Singleton.Operations.Update>> {
-        }
-    }
-}
-export declare namespace SingletonDecorator {
-    /**
-     * Action PropertyDecorator
-     */
-    function Action(options: ResourceDecorator.OperationOptions): ActionDecorator;
-    /**
-     * Create PropertyDecorator
-     */
-    type CreateDecorator = ((target: Object, propertyKey: 'create') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => CreateDecorator;
-        InputMaxContentSize: (sizeInBytes: number) => CreateDecorator;
-        InputPickFields: (...fields: Field.QualifiedName[]) => CreateDecorator;
-        InputOmitFields: (...fields: Field.QualifiedName[]) => CreateDecorator;
-        InputOverwriteFields: (fields: Record<string, CollectionDecorator.FieldDecoratorOptions>) => CreateDecorator;
-        OutputPickFields: (...fields: Field.QualifiedName[]) => CreateDecorator;
-        OutputOmitFields: (...fields: Field.QualifiedName[]) => CreateDecorator;
-        OutputOverwriteFields: (fields: Record<string, CollectionDecorator.FieldDecoratorOptions>) => CreateDecorator;
-    };
-    function Create(options?: Create.Options): CreateDecorator;
-}
-export declare namespace SingletonDecorator {
-    type GetDecorator = ((target: Object, propertyKey: 'get') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => GetDecorator;
-        OutputPickFields: (...fields: Field.QualifiedName[]) => GetDecorator;
-        OutputOmitFields: (...fields: Field.QualifiedName[]) => GetDecorator;
-        OutputOverwriteFields: (fields: Record<string, CollectionDecorator.FieldDecoratorOptions>) => GetDecorator;
-    };
-    function Get(options?: Get.Options): GetDecorator;
-}
-export declare namespace SingletonDecorator {
-    type DeleteDecorator = ((target: Object, propertyKey: 'delete') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => DeleteDecorator;
-    };
-    function Delete(options?: Delete.Options): DeleteDecorator;
-}
-export declare namespace SingletonDecorator {
-    type UpdateDecorator = ((target: Object, propertyKey: 'update') => void) & {
-        Parameter: (name: string, optionsOrType?: ResourceDecorator.ParameterOptions | string | Type) => UpdateDecorator;
-        InputMaxContentSize: (sizeInBytes: number) => UpdateDecorator;
-        InputPickFields: (...fields: Field.QualifiedName[]) => UpdateDecorator;
-        InputOmitFields: (...fields: Field.QualifiedName[]) => UpdateDecorator;
-        InputOverwriteFields: (fields: Record<string, CollectionDecorator.FieldDecoratorOptions>) => UpdateDecorator;
-        OutputPickFields: (...fields: Field.QualifiedName[]) => UpdateDecorator;
-        OutputOmitFields: (...fields: Field.QualifiedName[]) => UpdateDecorator;
-        OutputOverwriteFields: (fields: Record<string, CollectionDecorator.FieldDecoratorOptions>) => UpdateDecorator;
-    };
-    function Update(options?: Update.Options): UpdateDecorator;
-}
-export {};

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

@@ -1,49 +0,0 @@
-import { Combine, StrictOmit } from 'ts-gems';
-import type { ApiDocument } from '../api-document.js';
-import type { ComplexType } from '../data-type/complex-type.js';
-import type { Container } from './container.js';
-import type { Resource } from './resource.js';
-import { SingletonClass } from './singleton-class.js';
-import { SingletonDecorator } from './singleton-decorator.js';
-export interface Singleton extends SingletonClass {
-}
-export interface SingletonConstructor extends SingletonDecorator {
-    prototype: SingletonClass;
-    new (parent: ApiDocument | Container, init: Singleton.InitArguments): SingletonClass;
-}
-/**
- * @class Singleton
- * @decorator Singleton
- */
-export declare const Singleton: SingletonConstructor;
-/**
- * @namespace Singleton
- */
-export declare namespace Singleton {
-    interface InitArguments extends StrictOmit<Combine<Resource.InitArguments, SingletonDecorator.Metadata>, 'kind' | 'type'> {
-        name: string;
-        type: ComplexType;
-    }
-    interface DecoratorOptions extends Partial<StrictOmit<SingletonDecorator.Metadata, 'kind' | 'operations' | 'actions'>> {
-    }
-    interface Action {
-    }
-    namespace Action {
-    }
-    interface Create {
-    }
-    namespace Create {
-    }
-    interface Delete {
-    }
-    namespace Delete {
-    }
-    interface Get {
-    }
-    namespace Get {
-    }
-    interface Update {
-    }
-    namespace Update {
-    }
-}

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

@@ -1,17 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import type { ApiDocument } from '../api-document.js';
-import type { Container } from './container';
-import type { CrudOperation } from './crud-operation.js';
-import { CrudResource } from './crud-resource.js';
-import type { Storage } from './storage.js';
-import type { StorageDecorator } from './storage-decorator';
-export declare class StorageClass extends CrudResource {
-    readonly kind: OpraSchema.Resource.Kind;
-    constructor(parent: ApiDocument | Container, init: Storage.InitArguments);
-    getOperation(name: 'delete'): (CrudOperation & Omit<StorageDecorator.Delete.Metadata, keyof CrudOperation>) | undefined;
-    getOperation(name: 'get'): (CrudOperation & Omit<StorageDecorator.Get.Metadata, keyof CrudOperation>) | undefined;
-    getOperation(name: 'post'): (CrudOperation & Omit<StorageDecorator.Post.Metadata, keyof CrudOperation>) | undefined;
-    exportSchema(options?: {
-        webSafe?: boolean;
-    }): OpraSchema.Storage;
-}