@zenofolio/hyper-decor 1.0.4 → 1.0.7

package/dist/lib/openapi/decorators/api-parameter.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiParameter = ApiParameter;
+require("reflect-metadata");
+const parameter_helper_1 = require("../helpers/parameter.helper");
+function ApiParameter(options) {
+    return (target, propertyKey) => {
+        (0, parameter_helper_1.apiParameter)(target, propertyKey, options);
+    };
+}

package/dist/lib/openapi/decorators/api-request-body.decorator.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { RequestBody } from '../types';
+export declare function ApiRequestBody(options: RequestBody): (target: any, propertyKey: any) => void;

package/dist/lib/openapi/decorators/api-request-body.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiRequestBody = ApiRequestBody;
+require("reflect-metadata");
+const request_body_helper_1 = require("../helpers/request-body.helper");
+function ApiRequestBody(options) {
+    return (target, propertyKey) => {
+        (0, request_body_helper_1.apiRequestBody)(target, propertyKey, options);
+    };
+}

package/dist/lib/openapi/decorators/api-response.decorator.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+import { OpenApiResponses } from "../types";
+export declare function ApiResponse(options: OpenApiResponses): (target: any, propertyKey?: any, descriptor?: any) => any;

package/dist/lib/openapi/decorators/api-response.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiResponse = ApiResponse;
+require("reflect-metadata");
+const response_helper_1 = require("../helpers/response.helper");
+function ApiResponse(options) {
+    return (target, propertyKey, descriptor) => {
+        (0, response_helper_1.apiResponse)(target, propertyKey, options);
+    };
+}

package/dist/lib/openapi/decorators/api-security.decorator.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { SecurityRequirement } from '../types';
+export declare function ApiSecurity(options: SecurityRequirement): (target: any, propertyKey?: any, descriptor?: any) => void;

package/dist/lib/openapi/decorators/api-security.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiSecurity = ApiSecurity;
+require("reflect-metadata");
+const security_helper_1 = require("../helpers/security.helper");
+function ApiSecurity(options) {
+    return (target, propertyKey, descriptor) => {
+        (0, security_helper_1.apiSecurity)(target, options, propertyKey);
+    };
+}

package/dist/lib/openapi/decorators/api-tag.decorator.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { Tag } from '../types';
+export declare function ApiTag(options: Tag | string): (target: any) => void;

package/dist/lib/openapi/decorators/api-tag.decorator.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiTag = ApiTag;
+require("reflect-metadata");
+const tag_helper_1 = require("../helpers/tag.helper");
+function ApiTag(options) {
+    return (target) => {
+        if (typeof options === 'string') {
+            options = { name: options };
+        }
+        (0, tag_helper_1.apiTag)(target, options);
+    };
+}

package/dist/lib/openapi/decorators/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./api-method.decorator";
+export * from "./api-parameter.decorator";
+export * from "./api-request-body.decorator";
+export * from "./api-response.decorator";
+export * from "./api-security.decorator";
+export * from "./api-bearer-auth.decorator";
+export * from "./api-tag.decorator";

package/dist/lib/openapi/decorators/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api-method.decorator"), exports);
+__exportStar(require("./api-parameter.decorator"), exports);
+__exportStar(require("./api-request-body.decorator"), exports);
+__exportStar(require("./api-response.decorator"), exports);
+__exportStar(require("./api-security.decorator"), exports);
+__exportStar(require("./api-bearer-auth.decorator"), exports);
+__exportStar(require("./api-tag.decorator"), exports);

package/dist/lib/openapi/helpers/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./method.helper";
+export * from "./parameter.helper";
+export * from "./request-body.helper";
+export * from "./response.helper";
+export * from "./security.helper";
+export * from "./tag.helper";
+export * from "./openapi.helper";

package/dist/lib/openapi/helpers/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./method.helper"), exports);
+__exportStar(require("./parameter.helper"), exports);
+__exportStar(require("./request-body.helper"), exports);
+__exportStar(require("./response.helper"), exports);
+__exportStar(require("./security.helper"), exports);
+__exportStar(require("./tag.helper"), exports);
+__exportStar(require("./openapi.helper"), exports);

package/dist/lib/openapi/helpers/method.helper.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+import { Operation } from "../types";
+export declare function apimethod(target: any, propertyKey: string | symbol, options: Partial<Operation>): void;

package/dist/lib/openapi/helpers/method.helper.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apimethod = apimethod;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+const response_helper_1 = require("./response.helper");
+function apimethod(target, propertyKey, options) {
+    if (options.summary) {
+        Reflect.defineMetadata(constants_1.METHOD_SUMMARY, options.summary, target, propertyKey);
+    }
+    if (options.operationId) {
+        Reflect.defineMetadata(constants_1.METHOD_OPERATION_ID, options.operationId, target, propertyKey);
+    }
+    if (options.tags) {
+        Reflect.defineMetadata(constants_1.METHOD_TAGS, options.tags, target, propertyKey);
+    }
+    if (options.responses) {
+        (0, response_helper_1.apiResponse)(target, propertyKey, options.responses);
+    }
+}

package/dist/lib/openapi/helpers/openapi.helper.d.ts

@@ -0,0 +1,7 @@
+import { OpenAPIDocument } from "../types";
+/**
+ * Generates a complete OpenAPI 3.0.0 document from a HyperApp class.
+ *
+ * @param App The HyperApp class (usually decorated with @HyperApp)
+ */
+export declare function getOpenAPI(App: any): OpenAPIDocument;

package/dist/lib/openapi/helpers/openapi.helper.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOpenAPI = getOpenAPI;
+const tree_helper_1 = require("../../../__internals/helpers/tree.helper");
+/**
+ * Generates a complete OpenAPI 3.0.0 document from a HyperApp class.
+ *
+ * @param App The HyperApp class (usually decorated with @HyperApp)
+ */
+function getOpenAPI(App) {
+    var _a;
+    const tree = (0, tree_helper_1.getAppTree)(App);
+    const appMeta = tree.app;
+    const doc = {
+        openapi: "3.0.0",
+        info: {
+            title: appMeta.name || "API Documentation",
+            version: appMeta.version || "1.0.0",
+            description: appMeta.description || "",
+        },
+        paths: {},
+        components: Object.assign({ schemas: {}, securitySchemes: {} }, (_a = tree.openapi) === null || _a === void 0 ? void 0 : _a.components)
+    };
+    // Populate paths from the flattened tree paths
+    Object.entries(tree.paths).forEach(([path, routes]) => {
+        // Convert /v1/user/ to /v1/user (remove trailing slash except for root)
+        const normalizedPath = path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+        if (!doc.paths[normalizedPath]) {
+            doc.paths[normalizedPath] = {};
+        }
+        const pathItem = doc.paths[normalizedPath];
+        routes.forEach(route => {
+            var _a;
+            const method = route.method.toLowerCase();
+            // Merge route-level OpenAPI metadata
+            const operation = Object.assign(Object.assign({}, route.openapi), { responses: ((_a = route.openapi) === null || _a === void 0 ? void 0 : _a.responses) || {
+                    "200": { description: "Successful operation" }
+                } });
+            // Ensure operationId if missing for better client generation
+            if (!operation.operationId) {
+                operation.operationId = `${route.propertyKey}`;
+            }
+            pathItem[method] = operation;
+        });
+    });
+    // Apply any global tree processors that might have added data to tree.openapi
+    if (tree.openapi) {
+        Object.assign(doc, tree.openapi);
+    }
+    return doc;
+}

package/dist/lib/openapi/helpers/parameter.helper.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { OpenApiParameter } from '../types';
+export declare function apiParameter(target: any, propertyKey: string, options: OpenApiParameter): void;

package/dist/lib/openapi/helpers/parameter.helper.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiParameter = apiParameter;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function apiParameter(target, propertyKey, options) {
+    const existingParameters = Reflect.getMetadata(constants_1.PARAMETERS, target, propertyKey) || [];
+    existingParameters.push({
+        name: options.name,
+        in: options.in,
+        required: options.required || false,
+        description: options.description,
+        schema: options.schema,
+    });
+    Reflect.defineMetadata(constants_1.PARAMETERS, existingParameters, target, propertyKey);
+}

package/dist/lib/openapi/helpers/request-body.helper.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { RequestBody } from '../types';
+export declare function apiRequestBody(target: any, propertyKey: string, options: RequestBody): void;

package/dist/lib/openapi/helpers/request-body.helper.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiRequestBody = apiRequestBody;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function apiRequestBody(target, propertyKey, options) {
+    Reflect.defineMetadata(constants_1.REQUEST_BODY_DESCRIPTION, options.description, target, propertyKey);
+    Reflect.defineMetadata(constants_1.REQUEST_BODY_CONTENT, options.content, target, propertyKey);
+}

package/dist/lib/openapi/helpers/response.helper.d.ts

@@ -0,0 +1,3 @@
+import "reflect-metadata";
+import { OpenApiResponses } from "../types";
+export declare function apiResponse(target: any, propertyKey: string | symbol, options: OpenApiResponses): void;

package/dist/lib/openapi/helpers/response.helper.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiResponse = apiResponse;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function apiResponse(target, propertyKey, options) {
+    const existingResponses = Reflect.getMetadata(constants_1.RESPONSES, target, propertyKey) || {};
+    for (const key in options) {
+        if (options.hasOwnProperty(key)) {
+            const response = options[key];
+            existingResponses[key] = {
+                description: response.description,
+                content: response.content,
+            };
+        }
+    }
+    Reflect.defineMetadata(constants_1.RESPONSES, existingResponses, target, propertyKey);
+}

package/dist/lib/openapi/helpers/security.helper.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { SecurityRequirement } from '../types';
+export declare function apiSecurity(target: any, options: SecurityRequirement, propertyKey?: string): void;

package/dist/lib/openapi/helpers/security.helper.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiSecurity = apiSecurity;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function apiSecurity(target, options, propertyKey) {
+    const existingSecurity = propertyKey
+        ? Reflect.getMetadata(constants_1.SECURITY, target, propertyKey) || []
+        : Reflect.getMetadata(constants_1.SECURITY, target) || [];
+    existingSecurity.push(options);
+    if (propertyKey) {
+        Reflect.defineMetadata(constants_1.SECURITY, existingSecurity, target, propertyKey);
+    }
+    else {
+        Reflect.defineMetadata(constants_1.SECURITY, existingSecurity, target);
+    }
+}

package/dist/lib/openapi/helpers/tag.helper.d.ts

@@ -0,0 +1,3 @@
+import 'reflect-metadata';
+import { Tag } from '../types';
+export declare function apiTag(target: any, options: Tag): void;

package/dist/lib/openapi/helpers/tag.helper.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiTag = apiTag;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function apiTag(target, options) {
+    const existingTags = Reflect.getMetadata(constants_1.TAGS, target) || [];
+    existingTags.push({ name: options.name, description: options.description });
+    Reflect.defineMetadata(constants_1.TAGS, existingTags, target);
+}

package/dist/lib/openapi/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./metadata.registry";
+export * from "./constants";
+export * from "./collectors";
+export * from "./decorators";
+export * from "./helpers";
+export * from "./types";

package/dist/lib/openapi/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./metadata.registry"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./collectors"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./types"), exports);

package/dist/lib/openapi/metadata.registry.d.ts

@@ -0,0 +1,29 @@
+import { AppTree } from "../../__internals/helpers/tree.helper";
+export type CollectorType = "class" | "method" | "param";
+export type CollectorFn = (target: any, propertyKey?: string) => any;
+export type TreeProcessorFn = (tree: AppTree) => void;
+declare class OpenAPIMetadataRegistry {
+    private collectors;
+    private processors;
+    /**
+     * Register a custom metadata collector.
+     * @param type The level where the collector operates.
+     * @param collector The function that extracts metadata.
+     */
+    registerCollector(type: CollectorType, collector: CollectorFn): void;
+    /**
+     * Register a processor to transform the final AppTree.
+     * @param processor The function that enriches the tree.
+     */
+    registerProcessor(processor: TreeProcessorFn): void;
+    /**
+     * Returns all registered collectors for a specific type.
+     */
+    getCollectors(type: CollectorType): CollectorFn[];
+    /**
+     * Returns all registered tree processors.
+     */
+    getProcessors(): TreeProcessorFn[];
+}
+export declare const openApiRegistry: OpenAPIMetadataRegistry;
+export {};

package/dist/lib/openapi/metadata.registry.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openApiRegistry = void 0;
+class OpenAPIMetadataRegistry {
+    constructor() {
+        this.collectors = {
+            class: new Set(),
+            method: new Set(),
+            param: new Set(),
+        };
+        this.processors = new Set();
+    }
+    /**
+     * Register a custom metadata collector.
+     * @param type The level where the collector operates.
+     * @param collector The function that extracts metadata.
+     */
+    registerCollector(type, collector) {
+        this.collectors[type].add(collector);
+    }
+    /**
+     * Register a processor to transform the final AppTree.
+     * @param processor The function that enriches the tree.
+     */
+    registerProcessor(processor) {
+        this.processors.add(processor);
+    }
+    /**
+     * Returns all registered collectors for a specific type.
+     */
+    getCollectors(type) {
+        return Array.from(this.collectors[type]);
+    }
+    /**
+     * Returns all registered tree processors.
+     */
+    getProcessors() {
+        return Array.from(this.processors);
+    }
+}
+exports.openApiRegistry = new OpenAPIMetadataRegistry();

package/dist/lib/openapi/types.d.ts

@@ -0,0 +1,131 @@
+export interface OpenAPIDocument {
+    openapi: string;
+    info: Info;
+    paths: Paths;
+    components?: Components;
+    security?: SecurityRequirement[];
+    tags?: Tag[];
+}
+export interface Info {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: Contact;
+    license?: License;
+    version: string;
+}
+export interface Contact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface License {
+    name: string;
+    url?: string;
+}
+export interface Paths {
+    [path: string]: PathItem;
+}
+export interface PathItem {
+    get?: Operation;
+    post?: Operation;
+    put?: Operation;
+    delete?: Operation;
+    patch?: Operation;
+    head?: Operation;
+    options?: Operation;
+    trace?: Operation;
+}
+export interface Operation {
+    summary?: string;
+    description?: string;
+    operationId?: string;
+    tags?: Tag[];
+    parameters?: OpenApiParameter[];
+    requestBody?: RequestBody;
+    responses: OpenApiResponses;
+    security?: SecurityRequirement[];
+}
+export interface OpenApiParameter {
+    name: string;
+    in: "query" | "header" | "path" | "cookie";
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    schema: Schema;
+}
+export interface RequestBody {
+    description?: string;
+    content: {
+        [mediaType: string]: MediaType;
+    };
+}
+export interface MediaType {
+    schema: Schema;
+}
+export interface OpenApiResponses {
+    [statusCode: string]: OpenApiResponse;
+}
+export interface OpenApiResponse {
+    description: string;
+    content?: {
+        [mediaType: string]: MediaType;
+    };
+    headers?: {
+        [name: string]: Header;
+    };
+}
+export interface Header {
+    description?: string;
+    required?: boolean;
+    schema: Schema;
+}
+export interface Schema {
+    type: string;
+    format?: string;
+    items?: Schema;
+    properties?: {
+        [key: string]: Schema;
+    };
+    additionalProperties?: boolean;
+    example?: any;
+}
+export interface SecurityRequirement {
+    [securityScheme: string]: string[];
+}
+export interface Tag {
+    name: string;
+    description?: string;
+}
+export interface Components {
+    schemas?: {
+        [schemaName: string]: Schema;
+    };
+    responses?: {
+        [responseName: string]: OpenApiResponse;
+    };
+    parameters?: {
+        [parameterName: string]: OpenApiParameter;
+    };
+    securitySchemes?: {
+        [schemeName: string]: SecurityScheme;
+    };
+}
+export interface SecurityScheme {
+    type: "apiKey" | "http" | "oauth2" | "openIdConnect";
+    in?: "header" | "query" | "cookie";
+    name?: string;
+    scheme?: string;
+    bearerFormat?: string;
+    openIdConnectUrl?: string;
+    oauth2?: OAuth2Scheme;
+}
+export interface OAuth2Scheme {
+    authorizationUrl: string;
+    tokenUrl: string;
+    refreshUrl?: string;
+    scopes: {
+        [scope: string]: string;
+    };
+}

package/dist/stores/index.d.ts

@@ -0,0 +1 @@
+export * from "./scope.store";

package/dist/{common/openapi → stores}/index.js

@@ -14,5 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./collect-class-data"), exports);
-__exportStar(require("./collect-function-data"), exports);
+__exportStar(require("./scope.store"), exports);

package/dist/stores/scope.store.d.ts

@@ -0,0 +1,14 @@
+import { ScopeMap } from "../decorators";
+/**
+ * This class is a store for the scopes that are defined in the application.
+ *
+ */
+export declare class ScopeStore {
+    private static scopes;
+    static add(scope: ScopeMap): void;
+    static addAll(scopes: ScopeMap[]): void;
+    static getScopes(): ScopeMap[];
+    static getScopeNames(): string[];
+    static isEmpty(): boolean;
+    static clear(): void;
+}

package/dist/stores/scope.store.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScopeStore = void 0;
+/**
+ * This class is a store for the scopes that are defined in the application.
+ *
+ */
+class ScopeStore {
+    static add(scope) {
+        this.scopes.set(scope.scope, scope); // Evita duplicados basados en el nombre del scope
+    }
+    static addAll(scopes) {
+        scopes.forEach((scope) => this.add(scope));
+    }
+    static getScopes() {
+        return Array.from(this.scopes.values());
+    }
+    static getScopeNames() {
+        return Array.from(this.scopes.keys());
+    }
+    static isEmpty() {
+        return this.scopes.size === 0;
+    }
+    static clear() {
+        this.scopes.clear();
+    }
+}
+exports.ScopeStore = ScopeStore;
+ScopeStore.scopes = new Map();

package/dist/type.d.ts

@@ -1,10 +1,21 @@
 import type { Server } from "hyper-express";
+declare module "hyper-express" {
+    interface Request {
+        setValue(key: string, value: any): void;
+        getValue<T>(key: string, defaultValue?: T): T;
+    }
+}
+import { TransformerInput } from "./__internals/transform/transform.registry";
 export type HyperRoleOptions = string | string[];
 export type HyperScopeOptions = string | string[];
 export interface IHyperApplication extends Partial<Server> {
-    onPrepare(): void;
+    onPrepare?(): void;
+    emit?(topic: string, data: any): Promise<void>;
 }
-export type IHyperApp<T> = T & Server;
+export type IHyperApp<T> = T & Server & {
+    emit(topic: string, data: any): Promise<void>;
+    useTransform(transformer: TransformerInput): IHyperApp<T>;
+};
 export interface IHyperAppTarget {
     new (...args: any[]): IHyperApplication;
 }