@decaf-ts/for-nest 0.7.0 → 0.9.0

package/lib/types/ram/RamRequestTransformer.d.cts

@@ -1,4 +1,4 @@
-import { RequestToContextTransformer } from "../interceptors/context.cjs";
+import { RequestToContextTransformer } from "../interceptors/context.d.cts";
 export declare class RamTransformer implements RequestToContextTransformer<any> {
     constructor();
     from(req: any, ..._args: any[]): Promise<any>;

package/lib/types/ram/RamRequestTransformer.d.mts

@@ -1,4 +1,4 @@
-import { RequestToContextTransformer } from "../interceptors/context.js";
+import { RequestToContextTransformer } from "../interceptors/context.d.mts";
 export declare class RamTransformer implements RequestToContextTransformer<any> {
     constructor();
     from(req: any, ..._args: any[]): Promise<any>;

package/lib/types/ram/index.d.cts

@@ -1 +1 @@
-export * from "./RamRequestTransformer.cjs";
+export * from "./RamRequestTransformer.d.cts";

package/lib/types/ram/index.d.mts

@@ -1 +1 @@
-export * from "./RamRequestTransformer.js";
+export * from "./RamRequestTransformer.d.mts";

package/lib/types/request/DecafAuthHandler.d.cts

@@ -1,5 +1,5 @@
 import { ExecutionContext } from "@nestjs/common";
-import { AuthHandler } from "../types.cjs";
+import { AuthHandler } from "../types.d.cts";
 export declare class DecafAuthHandler implements AuthHandler {
     protected parseRequest(req: any): string;
     authorize(ctx: ExecutionContext, resource: string): Promise<void>;

package/lib/types/request/DecafAuthHandler.d.mts

@@ -1,5 +1,5 @@
 import { ExecutionContext } from "@nestjs/common";
-import { AuthHandler } from "../types.js";
+import { AuthHandler } from "../types.d.mts";
 export declare class DecafAuthHandler implements AuthHandler {
     protected parseRequest(req: any): string;
     authorize(ctx: ExecutionContext, resource: string): Promise<void>;

package/lib/types/request/DecafHandlerExecutor.d.cts

@@ -1,5 +1,5 @@
-import { DecafRequestContext } from "./DecafRequestContext.cjs";
-import { type DecafRequestHandler } from "../types.cjs";
+import { DecafRequestContext } from "./DecafRequestContext.d.cts";
+import { type DecafRequestHandler } from "../types.d.cts";
 /**
  * @description
  * Executes all registered {@link DecafRequestHandler} instances for the current request,

package/lib/types/request/DecafHandlerExecutor.d.mts

@@ -1,5 +1,5 @@
-import { DecafRequestContext } from "./DecafRequestContext.js";
-import { type DecafRequestHandler } from "../types.js";
+import { DecafRequestContext } from "./DecafRequestContext.d.mts";
+import { type DecafRequestHandler } from "../types.d.mts";
 /**
  * @description
  * Executes all registered {@link DecafRequestHandler} instances for the current request,

package/lib/types/request/DecafRequestContext.d.cts

@@ -1,4 +1,4 @@
-import { DecafServerCtx } from "../constants.cjs";
+import { DecafServerCtx } from "../constants.d.cts";
 export declare class DecafRequestContext<C extends DecafServerCtx = DecafServerCtx> {
     private readonly req;
     private _ctx?;

package/lib/types/request/DecafRequestContext.d.mts

@@ -1,4 +1,4 @@
-import { DecafServerCtx } from "../constants.js";
+import { DecafServerCtx } from "../constants.d.mts";
 export declare class DecafRequestContext<C extends DecafServerCtx = DecafServerCtx> {
     private readonly req;
     private _ctx?;

package/lib/types/request/DecafResponseInterceptor.d.cts

@@ -1,6 +1,6 @@
 import { NestInterceptor, ExecutionContext, CallHandler } from "@nestjs/common";
 import { Observable } from "rxjs";
-import { DecafRequestContext } from "./DecafRequestContext.cjs";
+import { DecafRequestContext } from "./DecafRequestContext.d.cts";
 export declare class DecafResponseInterceptor implements NestInterceptor {
     protected ctx: DecafRequestContext;
     constructor(ctx: DecafRequestContext);

package/lib/types/request/DecafResponseInterceptor.d.mts

@@ -1,6 +1,6 @@
 import { NestInterceptor, ExecutionContext, CallHandler } from "@nestjs/common";
 import { Observable } from "rxjs";
-import { DecafRequestContext } from "./DecafRequestContext.js";
+import { DecafRequestContext } from "./DecafRequestContext.d.mts";
 export declare class DecafResponseInterceptor implements NestInterceptor {
     protected ctx: DecafRequestContext;
     constructor(ctx: DecafRequestContext);

package/lib/types/request/index.d.cts

@@ -1,4 +1,4 @@
-export * from "./DecafAuthHandler.cjs";
-export * from "./DecafRequestContext.cjs";
-export * from "./DecafHandlerExecutor.cjs";
-export * from "./DecafResponseInterceptor.cjs";
+export * from "./DecafAuthHandler.d.cts";
+export * from "./DecafRequestContext.d.cts";
+export * from "./DecafHandlerExecutor.d.cts";
+export * from "./DecafResponseInterceptor.d.cts";

package/lib/types/request/index.d.mts

@@ -1,4 +1,4 @@
-export * from "./DecafAuthHandler.js";
-export * from "./DecafRequestContext.js";
-export * from "./DecafHandlerExecutor.js";
-export * from "./DecafResponseInterceptor.js";
+export * from "./DecafAuthHandler.d.mts";
+export * from "./DecafRequestContext.d.mts";
+export * from "./DecafHandlerExecutor.d.mts";
+export * from "./DecafResponseInterceptor.d.mts";

package/lib/types/types.d.cts

@@ -1,8 +1,8 @@
 import { Adapter, ConfigOf, ContextOf } from "@decaf-ts/core";
 import { Constructor } from "@decaf-ts/decoration";
 import { ExecutionContext, Type } from "@nestjs/common";
-import { RequestToContextTransformer } from "./interceptors/context.cjs";
-import { DecafRequestContext } from "./request/index.cjs";
+import { RequestToContextTransformer } from "./interceptors/context.d.cts";
+import { DecafRequestContext } from "./request/index.d.cts";
 export interface DecafRequestHandler<C extends DecafRequestContext = DecafRequestContext> {
     handle(context: C, req: Request, res: Response): Promise<void>;
 }

package/lib/types/types.d.mts

@@ -1,8 +1,8 @@
 import { Adapter, ConfigOf, ContextOf } from "@decaf-ts/core";
 import { Constructor } from "@decaf-ts/decoration";
 import { ExecutionContext, Type } from "@nestjs/common";
-import { RequestToContextTransformer } from "./interceptors/context.js";
-import { DecafRequestContext } from "./request/index.js";
+import { RequestToContextTransformer } from "./interceptors/context.d.mts";
+import { DecafRequestContext } from "./request/index.d.mts";
 export interface DecafRequestHandler<C extends DecafRequestContext = DecafRequestContext> {
     handle(context: C, req: Request, res: Response): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/for-nest",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "NestJS decaf integration",
   "type": "module",
   "exports": {

package/lib/types/bin/cli.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/types/cli-module.d.ts

@@ -1,11 +0,0 @@
-import { Command } from "commander";
-export declare function resolveInputPath(input?: string, exists?: (candidate: string) => boolean, candidates?: string[]): string;
-export declare function buildOutputFilePath(params: {
-    outputDir: string;
-    pkgName?: string;
-    name?: string;
-    fileName?: string;
-    appendVersion?: boolean;
-    version?: string;
-}): string;
-export default function nest(): Command;

package/lib/types/constants.d.ts

@@ -1,15 +0,0 @@
-import { AdapterFlags, Context } from "@decaf-ts/core";
-import { Logger } from "@decaf-ts/logging";
-export declare const DECAF_MODULE_OPTIONS = "DecafModuleOptions";
-export declare const DECAF_ADAPTER_ID = "DecafAdapter";
-export declare const DECAF_ROUTE = "DecafRoute";
-export declare const DECAF_HANDLERS: unique symbol;
-export declare const DECAF_ADAPTER_OPTIONS: unique symbol;
-export declare const AUTH_HANDLER: unique symbol;
-export declare const AUTH_META_KEY = "auth:meta";
-export declare const DECAF_CONTEXT_KEY: unique symbol;
-export type DecafServerFlags<LOG extends Logger = Logger> = AdapterFlags<LOG> & {
-    headers: Record<string, any>;
-    overrides: Record<string, any>;
-};
-export type DecafServerCtx = Context<DecafServerFlags>;

package/lib/types/controllers.d.ts

@@ -1,22 +0,0 @@
-import { Context, ContextOf, ContextualizedArgs, FlagsOf, MaybeContextualArg, MethodOrOperation, ModelService, Repo, Service } from "@decaf-ts/core";
-import { type Request } from "express";
-import { DecafServerCtx } from "./constants";
-import { Model, ModelConstructor } from "@decaf-ts/decorator-validation";
-import { DecafRequestContext } from "./request/DecafRequestContext";
-export declare abstract class DecafController<CONTEXT extends DecafServerCtx> extends Service<CONTEXT> {
-    protected readonly clientContext: DecafRequestContext;
-    protected constructor(clientContext: DecafRequestContext, name: string);
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: false, overrides?: Partial<FlagsOf<CONTEXT>>): ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<CONTEXT, ARGS>, operation: METHOD, allowCreate: true, overrides?: Partial<FlagsOf<CONTEXT>>): Promise<ContextualizedArgs<CONTEXT, ARGS, METHOD extends string ? true : false>>;
-    protected bindLoggerToRequest<RESULT extends ContextualizedArgs<any, any>>(value: RESULT | Promise<RESULT>, request?: Request): RESULT | Promise<RESULT>;
-}
-export declare abstract class DecafModelController<M extends Model<boolean>, C extends DecafServerCtx = DecafServerCtx> extends DecafController<C> {
-    private _persistence?;
-    abstract get class(): ModelConstructor<M>;
-    persistence(ctx?: Context<any>): Repo<M> | ModelService<M>;
-    protected constructor(clientContext: DecafRequestContext, name: string);
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<any, ARGS>, operation: METHOD): ContextualizedArgs<ContextOf<ReturnType<this["persistence"]>>, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<ContextOf<ReturnType<this["persistence"]>>, ARGS>, operation: METHOD, allowCreate: false, overrides?: Partial<FlagsOf<ContextOf<ReturnType<this["persistence"]>>>>): ContextualizedArgs<ContextOf<ReturnType<this["persistence"]>>, ARGS, METHOD extends string ? true : false>;
-    protected logCtx<ARGS extends any[] = any[], METHOD extends MethodOrOperation = MethodOrOperation>(args: MaybeContextualArg<ContextOf<ReturnType<this["persistence"]>>, ARGS>, operation: METHOD, allowCreate: true, overrides?: Partial<FlagsOf<ContextOf<ReturnType<this["persistence"]>>>>): Promise<ContextualizedArgs<ContextOf<ReturnType<this["persistence"]>>, ARGS, METHOD extends string ? true : false>>;
-}

package/lib/types/core-module.d.ts

@@ -1,17 +0,0 @@
-import { DynamicModule, OnApplicationShutdown } from "@nestjs/common";
-import { ModuleRef } from "@nestjs/core";
-import type { DecafModuleOptions } from "./types";
-import { Adapter, PersistenceService } from "@decaf-ts/core";
-import { Logger } from "@decaf-ts/logging";
-export declare class DecafCoreModule<CONF, ADAPTER extends Adapter<CONF, any, any, any>> implements OnApplicationShutdown {
-    private readonly options;
-    private readonly moduleRef;
-    private static _logger;
-    private static _persistence?;
-    protected static get persistence(): PersistenceService<any>;
-    protected static get log(): Logger;
-    constructor(options: DecafModuleOptions<CONF, ADAPTER>, moduleRef: ModuleRef);
-    static forRoot(options: DecafModuleOptions): DynamicModule;
-    static bootPersistence(options: DecafModuleOptions): Promise<Adapter<any, any, any, any>[]>;
-    onApplicationShutdown(): Promise<void>;
-}

package/lib/types/decaf-model/DecafModelModule.d.ts

@@ -1,9 +0,0 @@
-import { DynamicModule, Provider } from "@nestjs/common";
-import { DecafModuleOptions } from "../types";
-import { Model, ModelConstructor } from "@decaf-ts/decorator-validation";
-export declare function getModuleFor(flavour: string): {
-    new (): {};
-    readonly log: import("@decaf-ts/logging").Logger;
-    createModelServices<T extends Model<boolean>>(models: ModelConstructor<T>[]): Provider[];
-    forRoot(flavour: string, options?: Partial<DecafModuleOptions>): DynamicModule;
-};

package/lib/types/decaf-model/FromModelController.d.ts

@@ -1,61 +0,0 @@
-import { ModelService, type Repo } from "@decaf-ts/core";
-import { Model, ModelConstructor } from "@decaf-ts/decorator-validation";
-import { type DecafModelRoute } from "./decorators";
-import { ControllerConstructor } from "./types";
-import "../overrides";
-/**
- * @description
- * Factory and utilities for generating dynamic NestJS controllers from Decaf {@link Model} definitions.
- *
- * @summary
- * The `FromModelController` class provides the infrastructure necessary to automatically generate
- * strongly-typed CRUD controllers based on a given {@link ModelConstructor}. It inspects metadata from
- * the model, derives route paths, parameters, and generates a dynamic controller class at runtime with
- * full support for querying, creation, update, and deletion of model entities through a {@link Repo}.
- *
- * @template T The {@link Model} type associated with the generated controller.
- *
- * @param ModelClazz The model class to generate the controller from.
- *
- * @class FromModelController
- *
- * @example
- * ```ts
- * // Given a Decaf Model:
- * class User extends Model<User> {
- *   id!: string;
- *   name!: string;
- * }
- *
- * // Register controller:
- * const UserController = FromModelController.create(User);
- *
- * // NestJS will expose:
- * // POST   /user
- * // GET    /user/:id
- * // GET    /user/query/:method
- * // PUT    /user/:id
- * // DELETE /user/:id
- * ```
- *
- * @mermaid
- * sequenceDiagram
- *     participant Client
- *     participant Controller
- *     participant Repo
- *     participant DB
- *
- *     Client->>Controller: HTTP Request
- *     Controller->>Repo: Resolve repository for Model
- *     Repo->>DB: Execute DB operation
- *     DB-->>Repo: DB Result
- *     Repo-->>Controller: Model Instance(s)
- *     Controller-->>Client: JSON Response
- */
-export declare class FromModelController {
-    private static readonly log;
-    static getPersistence<T extends Model<boolean>>(ModelClazz: ModelConstructor<T>): Repo<T> | ModelService<T>;
-    static createQueryRoutesFromRepository<T extends Model<boolean>>(persistence: Repo<T> | ModelService<T>, prefix?: string): ControllerConstructor<T>;
-    static create<T extends Model<any>>(ModelConstr: ModelConstructor<T>): any;
-    static getRouteParametersFromModel<T extends Model<any>>(ModelClazz: ModelConstructor<T>): DecafModelRoute;
-}

package/lib/types/decaf-model/decorators/ApiOperationFromModel.d.ts

@@ -1,30 +0,0 @@
-import { CrudOperations } from "@decaf-ts/db-decorators";
-import { ModelConstructor } from "@decaf-ts/decorator-validation";
-import { HttpVerbs } from "./types";
-/**
- * @description Determines if a given CRUD operation is blocked for a specific model constructor.
- * @summary Retrieves the operation-blocking handler metadata stored on the provided model constructor (under `OperationKeys.REFLECT + OperationKeys.BLOCK`), executes it (if present) with its persisted arguments plus the requested operation, and returns whether the operation is blocked. If no handler exists, the operation is considered allowed (returns `false`).
- * @param {ModelConstructor<any>} ModelConstructor - The target model constructor whose metadata may include a blocking handler.
- * @param {CrudOperations} op - The CRUD operation to evaluate (e.g., `OperationKeys.CREATE`, `OperationKeys.READ`, `OperationKeys.UPDATE`, `OperationKeys.DELETE`).
- * @return {boolean} `true` when the operation is explicitly blocked by the model's handler; otherwise `false`.
- * @function isOperationBlocked
- */
-export declare function isOperationBlocked(ModelConstructor: ModelConstructor<any>, op: CrudOperations): boolean;
-/**
- * @description Conditionally applies an HTTP method decorator for a given model and verb, hiding the endpoint in Swagger (and not registering the route) when the model blocks that CRUD operation.
- * @summary Maps an HTTP verb to its corresponding `CrudOperations` key and Nest HTTP decorator (`@Get`, `@Post`, etc.). It checks `isOperationBlocked(ModelConstructor, crudOp)` and, if blocked, applies only `@ApiExcludeEndpoint()` (Swagger-hidden, no Nest route). If permitted, it applies the appropriate HTTP decorator with the optional `path`.
- * @param {ModelConstructor<any>} ModelConstructor - The model constructor used to resolve operation-blocking rules.
- * @param {HttpVerbs} verb - The HTTP verb to map (e.g., `"GET" | "POST" | "PUT" | "PATCH" | "DELETE"`).
- * @param {string} [path] - Optional route path passed through to the corresponding Nest HTTP method decorator.
- * @return {MethodDecorator} A method decorator that either excludes the endpoint from Swagger (and route registration) or applies the correct HTTP decorator.
- */
-export declare function ApiOperationFromModel(ModelConstructor: ModelConstructor<any>, verb: HttpVerbs, path?: string): MethodDecorator;
-/**
- * @description Conditionally applies an HTTP method decorator for a given model and verb, hiding the endpoint in Swagger (and not registering the route) when the model blocks that CRUD operation.
- * @summary Maps an HTTP verb to its corresponding `CrudOperations` key and Nest HTTP decorator (`@Get`, `@Post`, etc.). It checks `isOperationBlocked(ModelConstructor, crudOp)` and, if blocked, applies only `@ApiExcludeEndpoint()` (Swagger-hidden, no Nest route). If permitted, it applies the appropriate HTTP decorator with the optional `path`.
- * @param {ModelConstructor<any>} ModelConstructor - The model constructor used to resolve operation-blocking rules.
- * @param {HttpVerbs} verb - The HTTP verb to map (e.g., `"GET" | "POST" | "PUT" | "PATCH" | "DELETE"`).
- * @param {string} [path] - Optional route path passed through to the corresponding Nest HTTP method decorator.
- * @return {MethodDecorator} A method decorator that either excludes the endpoint from Swagger (and route registration) or applies the correct HTTP decorator.
- */
-export declare function BulkApiOperationFromModel(ModelConstructor: ModelConstructor<any>, verb: HttpVerbs, path?: string): MethodDecorator;

package/lib/types/decaf-model/decorators/ApiParamsFromModel.d.ts

@@ -1,13 +0,0 @@
-import type { DecafApiProperty } from "./types";
-/**
- * @description Applies a set of Swagger `@ApiParam` decorators generated from a typed specification array.
- * @summary Transforms each entry of the provided `ApiParam[]` into a corresponding `@ApiParam()` decorator (defaulting `description`, `required`, and `type` when omitted) and composes them into a single decorator via Nest's `applyDecorators`. Useful for synchronizing runtime route params with OpenAPI documentation in a concise, declarative way.
- * @param {ApiParam[]} [props=[]] Array describing path parameters to be documented.
- * @param {string} props[].name The parameter's name as it appears in the route template (e.g., `:id`).
- * @param {string} [props[].description] Human-readable explanation of the parameter; defaults to `"Path parameter: <name>"`.
- * @param {boolean} [props[].required=true] Whether the parameter is required; defaults to `true`.
- * @param {Constructor<any>} [props[].type=String] Constructor/type used by Swagger to infer schema (e.g., `String`, `Number`, `UUID`, custom class).
- * @return {any} A composed decorator applying all generated `@ApiParam` decorators to the target method or controller.
- * @function ApiParamsFromModel
- */
-export declare function ApiParamsFromModel(props?: DecafApiProperty[]): MethodDecorator & ClassDecorator;

package/lib/types/decaf-model/decorators/DecafBody.d.ts

@@ -1,5 +0,0 @@
-/**
- * @description Custom decorator that extracts the request body and instantiates it using the Model constructor
- * found on the controller. Handles both single objects and arrays.
- */
-export declare const DecafBody: (...dataOrPipes: unknown[]) => ParameterDecorator;

package/lib/types/decaf-model/decorators/DecafParams.d.ts

@@ -1,9 +0,0 @@
-import { DecafApiProperty } from "./types";
-/**
- * @description A higher-level decorator factory that leverages `OrderedParams` to extract route parameters in a specific order derived from a list of `ApiParam` definitions.
- * @summary `DecafParams` computes the order of route parameters based on the provided `ApiParam[]` specification (using each element’s `name`), then applies `OrderedParams(order)` as a parameter decorator. This enables parameter-level binding that remains consistent with the documented API parameter metadata.
- * @param {ApiParam[]} [props=[]] Array of `ApiParam` definitions whose `name` fields determine the parameter extraction order.
- * @return {ParameterDecorator} A NestJS parameter decorator that injects an ordered list of parameters and metadata into the controller method argument.
- */
-export declare function DecafParams(props?: DecafApiProperty[]): ParameterDecorator;
-export declare const DecafQuery: (...dataOrPipes: unknown[]) => ParameterDecorator;

package/lib/types/decaf-model/decorators/decorators.d.ts

@@ -1,29 +0,0 @@
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * A decorator function that applies authentication and authorization metadata to a NestJS controller or method.
- *
- * @param model - The model name or constructor function for the resource being accessed.
- * If a string is provided, it is used as the resource name.
- * If a constructor function is provided, its name is used as the resource name.
- *
- * @returns - A function that applies the authentication and authorization decorators to the target.
- *
- * @example
- * ```typescript
- * @Controller('users')
- * @Auth('User')
- * export class UsersController {
- *   // ...
- * }
- * ```
- *
- * @example
- * ```typescript
- * @Controller('users')
- * @Auth(User)
- * export class UsersController {
- *   // ...
- * }
- * ```
- */
-export declare function Auth(model?: string | Constructor): <TFunction extends Function, Y>(target: TFunction | object, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;

package/lib/types/decaf-model/decorators/index.d.ts

@@ -1,7 +0,0 @@
-export * from "./types";
-export * from "./ApiOperationFromModel";
-export * from "./ApiParamsFromModel";
-export * from "./DecafBody";
-export * from "./DecafParams";
-export * from "./utils";
-export * from "./decorators";

package/lib/types/decaf-model/decorators/types.d.ts

@@ -1,23 +0,0 @@
-export type HttpVerbs = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-export type DecafApiProperty = {
-    name: string;
-    description?: string;
-    required?: boolean;
-    type?: any;
-};
-export type DecafModelRoute = {
-    path: string;
-    description?: string;
-    apiProperties: DecafApiProperty[];
-    getPK: (...args: Array<string | number>) => string;
-};
-export type DecafParamProps = {
-    raw: Record<string, string | number>;
-    keysInOrder: Array<string>;
-    valuesInOrder: Array<string | number>;
-};
-export interface DecafRouteDecOptions {
-    path: string;
-    httpMethod: HttpVerbs;
-    handler: PropertyDescriptor;
-}

package/lib/types/decaf-model/decorators/utils.d.ts

@@ -1,11 +0,0 @@
-import { HttpVerbs } from "./types";
-/**
- * Maps an HTTP verb to its corresponding NestJS method decorator.
- *
- * @param verb - HTTP verb to be converted (e.g. GET, POST, PUT, PATCH, DELETE).
- * @returns A NestJS method decorator matching the provided HTTP verb.
- *
- * @throws {Error} If the provided HTTP verb is not supported or not mapped
- * to a NestJS decorator.
- */
-export declare function HttpVerbToDecorator(verb: HttpVerbs): (path?: string) => MethodDecorator;

package/lib/types/decaf-model/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./decorators";
-export * from "./DecafModelModule";
-export * from "./FromModelController";

package/lib/types/decaf-model/types.d.ts

@@ -1,7 +0,0 @@
-import { DecafModelController } from "../controllers";
-import { Model } from "@decaf-ts/decorator-validation";
-export type ControllerConstructor<T extends Model<boolean>> = new (...args: any[]) => DecafModelController<T>;
-export type DecoratorBundle = {
-    method: MethodDecorator[];
-    params?: ParameterDecorator[];
-};

package/lib/types/decaf-model/utils.d.ts

@@ -1,10 +0,0 @@
-import { type DecoratorBundle } from "./types";
-import { type DecafParamProps, HttpVerbs } from "./decorators";
-import { DirectionLimitOffset, ModelService, Repo } from "@decaf-ts/core";
-import { Model } from "@decaf-ts/decorator-validation";
-import { DecafModelController } from "../controllers";
-export declare function getApiDecorators(methodName: string, routePath: string, httpVerb: HttpVerbs, includeQueryParams?: boolean): DecoratorBundle;
-export declare function applyApiDecorators(target: any, methodName: string, descriptor: PropertyDescriptor, decorators: DecoratorBundle): void;
-export declare function resolvePersistenceMethod<T extends Model<boolean>>(persistence: Repo<T> | ModelService<T>, methodName: string, ...args: any[]): any;
-export declare function createRouteHandler<T>(methodName: string): (this: DecafModelController<any>, pathParams: DecafParamProps, queryParams: DirectionLimitOffset) => Promise<T>;
-export declare function defineRouteMethod(ControllerClass: new (...args: any[]) => any, methodName: string, handler: (...args: any[]) => any): PropertyDescriptor | undefined;

package/lib/types/decoration.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/types/events-module/DecafStreamModule.d.ts

@@ -1,4 +0,0 @@
-import { DynamicModule } from "@nestjs/common";
-export declare class DecafStreamModule {
-    static forFlavours(flavours: string[], path?: string): DynamicModule;
-}

package/lib/types/events-module/EventsController.d.ts

@@ -1,11 +0,0 @@
-import { DecafController } from "../controllers";
-import { DecafRequestContext } from "../request";
-import { MessageEvent } from "@nestjs/common";
-import { Observable } from "rxjs";
-import { DecafServerCtx } from "../constants";
-export declare class EventsController extends DecafController<DecafServerCtx> {
-    private readonly adapters;
-    constructor(clientContext: DecafRequestContext, flavours: string[]);
-    listen(): Observable<MessageEvent>;
-    listenForModel(model: string): Observable<MessageEvent>;
-}

package/lib/types/events-module/constant.d.ts

@@ -1 +0,0 @@
-export declare const LISTENING_ADAPTERS_FLAVOURS: unique symbol;

package/lib/types/events-module/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./EventsController";
-export * from "./DecafStreamModule";

package/lib/types/events-module/utils.d.ts

@@ -1 +0,0 @@
-export declare function normalizeEventResponse(args: any[]): unknown[];