svelte-reflector 1.3.3 → 1.3.5

package/dist/core/CodegenContext.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Per-run codegen state. Replaces module-level mutable globals so two
+ * concurrent Reflector instances don't corrupt each other's output.
+ *
+ * - `enumTypes`: maps the joined enum literal string (e.g. `'a','b','c'`) to
+ *   its generated type name. `EnumProp` writes here on first sighting and
+ *   reads back the stable name on repeat sightings.
+ * - `mockedParams`: set of path-param names that need `$state` fallbacks in
+ *   the generated `MockedParams` class. Written by `ModuleClassBuilder` when
+ *   it sees path params.
+ */
+export declare class CodegenContext {
+    readonly enumTypes: Map<string, string>;
+    readonly mockedParams: Set<string>;
+}

package/dist/core/CodegenContext.js

@@ -0,0 +1,15 @@
+/**
+ * Per-run codegen state. Replaces module-level mutable globals so two
+ * concurrent Reflector instances don't corrupt each other's output.
+ *
+ * - `enumTypes`: maps the joined enum literal string (e.g. `'a','b','c'`) to
+ *   its generated type name. `EnumProp` writes here on first sighting and
+ *   reads back the stable name on repeat sightings.
+ * - `mockedParams`: set of path-param names that need `$state` fallbacks in
+ *   the generated `MockedParams` class. Written by `ModuleClassBuilder` when
+ *   it sees path params.
+ */
+export class CodegenContext {
+    enumTypes = new Map();
+    mockedParams = new Set();
+}

package/dist/core/Reflector.d.ts

@@ -0,0 +1,25 @@
+import { Module } from "./module/Module.js";
+import { Schema } from "./schema/Schema.js";
+import type { ComponentsObject, PathsObject } from "../types/open-api-spec.interface.js";
+import type { FieldConfigs, TypeImports } from "../types/types.js";
+import type { ReflectorConfig } from "./config/ReflectorConfig.js";
+export declare class Reflector {
+    readonly schemas: Schema[];
+    readonly modules: Module[];
+    readonly propertiesNames: Set<string>;
+    private readonly registry;
+    private readonly typeImports;
+    private readonly config;
+    private readonly context;
+    private readonly srcDir;
+    constructor(params: {
+        components: ComponentsObject;
+        paths: PathsObject;
+        fieldConfigs: FieldConfigs;
+        typeImports: TypeImports;
+        apiImport: string;
+        experimentalFeatures?: boolean;
+        config?: Partial<ReflectorConfig>;
+    });
+    build(): Promise<{}>;
+}

package/dist/core/Reflector.js

@@ -0,0 +1,66 @@
+import * as path from "node:path";
+import * as fs from "node:fs";
+import * as process from "node:process";
+import { Source } from "../file.js";
+import { Module } from "./module/Module.js";
+import { Schema } from "./schema/Schema.js";
+import { CodegenContext } from "./CodegenContext.js";
+import { InlineSchemaPromoter } from "./openapi/InlineSchemaPromoter.js";
+import { SchemaRegistry } from "./schema/SchemaRegistry.js";
+import { ModuleFactory } from "./module/ModuleFactory.js";
+import { ModuleSchemaFileBuilder } from "./module/ModuleSchemaFileBuilder.js";
+import { RuntimeFilesEmitter } from "./emit/RuntimeFilesEmitter.js";
+import { resolveReflectorConfig } from "./config/ReflectorConfig.js";
+import { generatedDir } from "../vars.global.js";
+export class Reflector {
+    schemas;
+    modules;
+    propertiesNames;
+    registry;
+    typeImports;
+    config;
+    context = new CodegenContext();
+    srcDir = path.resolve(process.cwd(), `${generatedDir}/controllers`);
+    constructor(params) {
+        const { components, paths, fieldConfigs, typeImports, apiImport, experimentalFeatures, config } = params;
+        this.typeImports = typeImports;
+        this.config = resolveReflectorConfig(config);
+        InlineSchemaPromoter.promote(components, paths);
+        this.modules = ModuleFactory.build({
+            paths,
+            apiImport,
+            experimentalFeatures: experimentalFeatures ?? false,
+            context: this.context,
+            config: this.config,
+        });
+        this.registry = new SchemaRegistry({ components, fieldConfigs, context: this.context });
+        this.schemas = this.registry.schemas;
+        this.propertiesNames = this.registry.propertiesNames;
+    }
+    async build() {
+        fs.rmSync(this.srcDir, { recursive: true, force: true });
+        fs.mkdirSync(this.srcDir, { recursive: true });
+        const moduleSchemaFiles = [];
+        for (const module of this.modules) {
+            if (module.methods.length === 0 || module.schemaClassNames.length === 0)
+                continue;
+            const neededSchemas = this.registry.resolveTransitiveDeps(module.schemaClassNames);
+            if (neededSchemas.length === 0)
+                continue;
+            const data = ModuleSchemaFileBuilder.build({ schemas: neededSchemas, typeImports: this.typeImports, config: this.config });
+            const schemaFilePath = module.src.path.replace(".module.svelte.ts", ".schema.svelte.ts");
+            moduleSchemaFiles.push(new Source({ path: schemaFilePath, data }));
+        }
+        const runtimeFiles = RuntimeFilesEmitter.build({
+            propertiesNames: this.propertiesNames,
+            context: this.context,
+        });
+        await Promise.all([
+            ...moduleSchemaFiles.map((f) => f.save()),
+            ...runtimeFiles.map((f) => f.save()),
+            ...this.modules.filter((m) => m.methods.length > 0).map((m) => m.src.save()),
+            ...this.modules.filter((m) => m.methods.length > 0 && m.apiSrc).map((m) => m.apiSrc.save()),
+        ]);
+        return {};
+    }
+}

package/dist/core/api/ApiClassBuilder.d.ts

@@ -0,0 +1,23 @@
+import type { Method } from "../method/Method.js";
+import type { ModuleImports } from "../module/ModuleImports.js";
+import type { ModuleClassBuilder } from "../module/ModuleClassBuilder.js";
+export interface ApiEndpointBlock {
+    paramCode: string;
+    classCode: string;
+    schemaEntries: Set<string>;
+}
+export declare class ApiClassBuilder {
+    private readonly imports;
+    private readonly methodGenerator;
+    private readonly callStrategy;
+    private readonly paramProcessor;
+    constructor(params: {
+        imports: ModuleImports;
+        classBuilder: ModuleClassBuilder;
+    });
+    build(params: {
+        method: Method;
+    }): ApiEndpointBlock | null;
+    private buildStateProperties;
+    private buildResetLines;
+}

package/dist/core/api/ApiClassBuilder.js

@@ -0,0 +1,106 @@
+import { capitalizeFirstLetter } from "../../helpers/helpers.js";
+import { MethodValidator } from "../method/MethodValidator.js";
+import { CallMethodGenerator } from "../generators/CallMethodGenerator.js";
+import { ApiCallStrategy } from "../generators/ApiCallStrategy.js";
+import { ApiParamProcessor } from "./ApiParamProcessor.js";
+export class ApiClassBuilder {
+    imports;
+    methodGenerator = new CallMethodGenerator();
+    callStrategy = new ApiCallStrategy();
+    paramProcessor;
+    constructor(params) {
+        this.imports = params.imports;
+        this.paramProcessor = new ApiParamProcessor({
+            imports: params.imports,
+            classBuilder: params.classBuilder,
+        });
+    }
+    build(params) {
+        const { method } = params;
+        if (MethodValidator.isSkippable(method))
+            return null;
+        const { request, headers, cookies, paths, querys } = method;
+        const { bodyType, responseType, attributeType, isPrimitiveResponse } = request;
+        // Process per-endpoint params
+        const processedParams = this.paramProcessor.process({
+            methodName: capitalizeFirstLetter(method.name),
+            querys,
+            paths,
+            headers,
+            cookies,
+        });
+        // Build state properties
+        const stateProps = this.buildStateProperties(method);
+        // Build the call method
+        const callMethod = this.methodGenerator.generate(method, this.callStrategy);
+        // Build reset method
+        const resetLines = this.buildResetLines(method, processedParams.paramReset);
+        // Collect schema entries
+        const schemaEntries = new Set();
+        if (bodyType) {
+            schemaEntries.add(bodyType);
+        }
+        if (responseType && responseType !== "response" && !isPrimitiveResponse) {
+            schemaEntries.add(`type ${responseType}Interface`);
+            schemaEntries.add(responseType);
+        }
+        // Handle form imports
+        if (attributeType === "form" && bodyType) {
+            this.imports.addReflectorImport("isFormValid");
+        }
+        // Handle list imports
+        if (attributeType === "list") {
+            this.imports.addReflectorImport("genericArrayBundler");
+        }
+        const className = capitalizeFirstLetter(method.name);
+        const classCode = `
+      export class ${className} {
+        ${stateProps.join(";")}
+        ${processedParams.paramAttributes.map((a) => `${a};`).join("\n        ")}
+
+        ${callMethod}
+
+        reset() {
+          ${resetLines.join(";")}
+        }
+      }
+    `;
+        const paramCode = processedParams.paramClasses.join("\n");
+        return { paramCode, classCode, schemaEntries };
+    }
+    buildStateProperties(method) {
+        const { attributeType, responseType, bodyType, isPrimitiveResponse } = method.request;
+        const props = ["loading = $state<boolean>(false)"];
+        if (attributeType === "form" && bodyType) {
+            // For form endpoints, the form IS the data
+            props.push(`form = new ${bodyType}()`);
+        }
+        else if (attributeType === "list") {
+            props.push(`data = $state<${responseType}['data']>([])`);
+            props.push("totalPages = $state<number>(1)");
+        }
+        else if (attributeType === "entity" && responseType && !isPrimitiveResponse) {
+            props.push(`data = $state<${responseType} | undefined>()`);
+        }
+        else {
+            props.push("data = $state<unknown>(undefined)");
+        }
+        return props;
+    }
+    buildResetLines(method, paramReset) {
+        const { attributeType, bodyType } = method.request;
+        const lines = [];
+        if (attributeType === "form" && bodyType) {
+            lines.push(`this.form = new ${bodyType}()`);
+        }
+        else if (attributeType === "list") {
+            lines.push("this.data = []");
+            lines.push("this.totalPages = 1");
+        }
+        else {
+            lines.push("this.data = undefined");
+        }
+        lines.push(...paramReset);
+        return lines;
+    }
+}

package/dist/core/api/ApiFileBuilder.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleImports } from "../module/ModuleImports.js";
+import type { ApiEndpointBlock } from "./ApiClassBuilder.js";
+export declare class ApiFileBuilder {
+    private readonly imports;
+    constructor(params: {
+        imports: ModuleImports;
+    });
+    build(params: {
+        endpointBlocks: ApiEndpointBlock[];
+        classImports: string;
+    }): string;
+}

package/dist/core/api/ApiFileBuilder.js

@@ -0,0 +1,24 @@
+export class ApiFileBuilder {
+    imports;
+    constructor(params) {
+        this.imports = params.imports;
+    }
+    build(params) {
+        const { endpointBlocks, classImports } = params;
+        const reflectorImports = this.imports.buildReflectorImportsLine();
+        const enumImports = this.imports.buildEnumImportsLine();
+        const mockedImports = this.imports.buildMockedImportsLine();
+        const sections = endpointBlocks.map((block) => {
+            return `${block.paramCode}\n${block.classCode}`;
+        });
+        return `
+      ${this.imports.getImportsArray().join(";")}
+      ${reflectorImports}
+      ${mockedImports}
+      ${enumImports}
+      ${classImports}
+
+      ${sections.join("\n\n")}
+    `;
+    }
+}

package/dist/core/api/ApiMethodGenerator.d.ts

@@ -0,0 +1,17 @@
+import type { Method } from "../../method.js";
+export declare class ApiMethodGenerator {
+    private readonly endpointBuilder;
+    generate(method: Method): string;
+    private buildProps;
+    private buildPathsInfo;
+    private buildApiCall;
+    private buildListCall;
+    private buildEntityCall;
+    private buildFormCall;
+    private buildDeleteCall;
+    private buildParamsType;
+    private buildDescription;
+    private buildMethodReturn;
+    private joinProps;
+    private buildQuerys;
+}

package/dist/core/api/ApiMethodGenerator.js

@@ -0,0 +1,176 @@
+import { MethodEndpointBuilder } from "../method/MethodEndpointBuilder.js";
+export class ApiMethodGenerator {
+    endpointBuilder = new MethodEndpointBuilder();
+    generate(method) {
+        const description = this.buildDescription(method);
+        const endpoint = this.endpointBuilder.build(method.endpoint, method.paths);
+        const apiCall = this.buildApiCall(method);
+        const props = this.buildProps(method);
+        const pathsInfo = this.buildPathsInfo(method);
+        const paramsType = this.buildParamsType(method, pathsInfo);
+        return `
+      ${description}
+      async call(params?: ${paramsType}) {
+
+        const behavior = params?.behavior ?? new Behavior();
+        const { onError, onSuccess } = behavior;
+
+        this.loading = true;
+        ${props}
+        const endpoint = ${endpoint}
+
+        ${apiCall.outside}
+
+        try {
+          ${apiCall.inside}
+          await onSuccess?.(response);
+
+          return ${this.buildMethodReturn(method)};
+        } catch (e) {
+          let parsedError: ApiErrorResponse;
+          try {
+            parsedError = JSON.parse((e as Error).message) as ApiErrorResponse;
+          } catch {
+            parsedError = { error: 'unknown', message: (e as Error).message ?? String(e) };
+          }
+          return await onError?.(parsedError);
+        } finally {
+          this.loading = false;
+        }
+      }
+    `;
+    }
+    buildProps(method) {
+        const { querys, paths, cookies } = method;
+        const lines = [];
+        if (querys.length > 0) {
+            lines.push(`const { ${querys.map((x) => x.name).join(", ")} } = this.querys.bundle()`);
+        }
+        if (paths.length > 0) {
+            lines.push(`const { ${paths.map((x) => x.name).join(", ")} } = params?.paths ?? this.paths`);
+        }
+        if (cookies.length > 0) {
+            lines.push(`const cookies = this.cookies`);
+        }
+        return lines.join("\n");
+    }
+    buildPathsInfo(method) {
+        const { paths } = method;
+        if (paths.length === 0)
+            return undefined;
+        return `{ ${paths
+            .map((p) => {
+            const type = p.rawType ?? p.type;
+            return `${p.name}: ${type}`;
+        })
+            .join("; ")} }`;
+    }
+    buildApiCall(method) {
+        const { attributeType, apiType, responseType, bodyType, hasEnumResponse } = method.request;
+        const responseTypeStr = hasEnumResponse && responseType ? responseType : method.responseTypeInterface;
+        if (attributeType === "list") {
+            return this.buildListCall(method, responseTypeStr);
+        }
+        if (attributeType === "entity") {
+            return this.buildEntityCall(method, responseTypeStr);
+        }
+        if (apiType === "post" || apiType === "put" || apiType === "patch") {
+            return this.buildFormCall(method, responseTypeStr, bodyType);
+        }
+        if (apiType === "delete") {
+            return this.buildDeleteCall(responseTypeStr);
+        }
+        return { inside: "", outside: "" };
+    }
+    buildListCall(method, responseType) {
+        const querys = this.joinProps(method.querys);
+        const inside = `
+      const response = await api.get<${responseType}, unknown>({
+        endpoint,
+        queryData: { ${querys} }
+      })
+      this.data = ${method.request.responseType}.from(response.data);
+      this.totalPages = response.totalPages;
+    `;
+        return { inside, outside: "" };
+    }
+    buildEntityCall(method, responseType) {
+        const rType = method.request.responseType;
+        const isPrimitive = method.request.isPrimitiveResponse;
+        const querys = this.buildQuerys(method.querys);
+        const buildedThisResponseType = rType && !isPrimitive
+            ? `this.data = new ${rType}({ data: response })`
+            : "";
+        const inside = `
+      const response = await api.get<${responseType}, unknown>({
+        endpoint,
+        ${querys}
+      })
+
+      ${buildedThisResponseType}
+    `;
+        return { inside, outside: "" };
+    }
+    buildFormCall(method, responseType, bodyType) {
+        const { apiType } = method.request;
+        const hasHeaders = method.headers.length > 0;
+        const hasData = !!bodyType;
+        const outside = [];
+        if (hasData) {
+            outside.push(`const data = this.form.bundle()`);
+        }
+        if (hasHeaders) {
+            outside.push(`const headers = this.headers.bundle()`);
+        }
+        const inside = `
+      const response = await api.${apiType}<${responseType}>({
+        endpoint,
+        ${hasData ? "data," : ""}
+        ${hasHeaders ? "headers," : ""}
+      })
+    `;
+        return { inside, outside: outside.join("\n") };
+    }
+    buildDeleteCall(responseType) {
+        const inside = `
+      const response = await api.delete<${responseType}, unknown>({
+        endpoint,
+      })
+    `;
+        return { inside, outside: "" };
+    }
+    buildParamsType(method, paramsPaths) {
+        const responseType = method.responseTypeInterface;
+        if (paramsPaths) {
+            return `ApiCallParams<${responseType}, ${paramsPaths}>`;
+        }
+        return `ApiCallParams<${responseType}>`;
+    }
+    buildDescription(method) {
+        return `/** ${method.description ?? ""} */`;
+    }
+    buildMethodReturn(method) {
+        const { attributeType, responseType, hasEnumResponse, isPrimitiveResponse } = method.request;
+        if (attributeType === "list") {
+            return "this.data";
+        }
+        if (!responseType) {
+            return "null";
+        }
+        if (hasEnumResponse) {
+            return "response.data";
+        }
+        if (isPrimitiveResponse) {
+            return "response";
+        }
+        return `new ${responseType}({ data: response })`;
+    }
+    joinProps(props) {
+        return props.map((x) => x.name).join(",");
+    }
+    buildQuerys(querys) {
+        if (querys.length === 0)
+            return "";
+        return `queryData: {${querys.map((q) => q.name).join(",")}}`;
+    }
+}

package/dist/core/api/ApiParamProcessor.d.ts

@@ -0,0 +1,24 @@
+import type { AttributeProp } from "../../types/types.js";
+import type { PrimitiveProp } from "../../props/primitive.property.js";
+import type { ModuleImports } from "../module/ModuleImports.js";
+import type { ModuleClassBuilder } from "../module/ModuleClassBuilder.js";
+export interface ApiProcessedParams {
+    paramClasses: string[];
+    paramAttributes: string[];
+    paramReset: string[];
+}
+export declare class ApiParamProcessor {
+    private readonly imports;
+    private readonly classBuilder;
+    constructor(params: {
+        imports: ModuleImports;
+        classBuilder: ModuleClassBuilder;
+    });
+    process(params: {
+        methodName: string;
+        querys: AttributeProp[];
+        paths: PrimitiveProp[];
+        headers: PrimitiveProp[];
+        cookies: PrimitiveProp[];
+    }): ApiProcessedParams;
+}

package/dist/core/api/ApiParamProcessor.js

@@ -0,0 +1,36 @@
+import { capitalizeFirstLetter } from "../../helpers/helpers.js";
+export class ApiParamProcessor {
+    imports;
+    classBuilder;
+    constructor(params) {
+        this.imports = params.imports;
+        this.classBuilder = params.classBuilder;
+    }
+    process(params) {
+        const { methodName, cookies, headers, paths, querys } = params;
+        const paramClasses = [];
+        const paramAttributes = [];
+        const paramReset = [];
+        const processParam = (paramData) => {
+            const { paramType, attrName, props } = paramData;
+            const className = `${capitalizeFirstLetter(methodName)}${capitalizeFirstLetter(paramType)}`;
+            paramClasses.push(this.classBuilder.buildClassProps({ props, name: paramType, className }));
+            paramAttributes.push(`${attrName} = new ${className}()`);
+            paramReset.push(`this.${attrName} = new ${className}()`);
+        };
+        const argEntries = [
+            { attrName: "querys", props: querys },
+            { attrName: "headers", props: headers },
+            { attrName: "paths", props: paths },
+            { attrName: "cookies", props: cookies },
+        ];
+        for (const { attrName, props } of argEntries) {
+            if (!props.length)
+                continue;
+            this.imports.addReflectorImport("QueryBuilder");
+            const paramType = capitalizeFirstLetter(attrName);
+            processParam({ paramType, attrName, props });
+        }
+        return { paramClasses, paramAttributes, paramReset };
+    }
+}

package/dist/core/config/ReflectorConfig.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Isolates the consumer's framework conventions (import aliases, env flag
+ * name) from the codegen core. Defaults reproduce the previous hard-coded
+ * SvelteKit paths so existing consumers don't need to change anything.
+ */
+export interface ReflectorConfig {
+    /** Alias that resolves to the generated reflector folder (e.g. `$reflector`). */
+    reflectorAlias: string;
+    /** Full import path to the validators/sanitizers module. */
+    validatorsImport: string;
+    /** Module path for the environment flag (e.g. `$env/static/public`). */
+    environmentImport: string;
+    /** Name of the exported environment flag — values other than `DEV` are treated as prod. */
+    environmentFlag: string;
+}
+export declare const DEFAULT_REFLECTOR_CONFIG: ReflectorConfig;
+export declare function resolveReflectorConfig(partial?: Partial<ReflectorConfig>): ReflectorConfig;

package/dist/core/config/ReflectorConfig.js

@@ -0,0 +1,9 @@
+export const DEFAULT_REFLECTOR_CONFIG = {
+    reflectorAlias: "$reflector",
+    validatorsImport: "$lib/sanitizers/validateFormats",
+    environmentImport: "$env/static/public",
+    environmentFlag: "PUBLIC_ENVIRONMENT",
+};
+export function resolveReflectorConfig(partial) {
+    return { ...DEFAULT_REFLECTOR_CONFIG, ...(partial ?? {}) };
+}

package/dist/core/emit/RuntimeFilesEmitter.d.ts

@@ -0,0 +1,13 @@
+import { Source } from "../../file.js";
+import type { CodegenContext } from "../CodegenContext.js";
+/**
+ * Emits the shared runtime-support files that sit alongside the generated
+ * module files: the reflector runtime template, the FIELD_NAMES list, the
+ * enum unions, and the MockedParams class used by path-param stubs.
+ */
+export declare class RuntimeFilesEmitter {
+    static build(params: {
+        propertiesNames: Set<string>;
+        context: CodegenContext;
+    }): Source[];
+}

package/dist/core/emit/RuntimeFilesEmitter.js

@@ -0,0 +1,55 @@
+import * as path from "node:path";
+import * as process from "node:process";
+import { Source } from "../../file.js";
+import { loadReflectorTemplate } from "../../loadTemplate.js";
+import { generatedDir } from "../../vars.global.js";
+import { dedent } from "../../helpers/codegen.js";
+function generated(relPath) {
+    return path.resolve(process.cwd(), `${generatedDir}/${relPath}`);
+}
+/**
+ * Emits the shared runtime-support files that sit alongside the generated
+ * module files: the reflector runtime template, the FIELD_NAMES list, the
+ * enum unions, and the MockedParams class used by path-param stubs.
+ */
+export class RuntimeFilesEmitter {
+    static build(params) {
+        const { propertiesNames, context } = params;
+        const typesSrc = new Source({
+            path: generated("reflector.svelte.ts"),
+            data: loadReflectorTemplate(),
+        });
+        const fieldLiterals = Array.from(propertiesNames).map((p) => `'${p}'`);
+        const fieldsFile = new Source({
+            path: generated("fields.ts"),
+            data: dedent `
+        export const FIELD_NAMES = [
+          ${fieldLiterals}
+        ] as const;
+        export type FieldName = (typeof FIELD_NAMES)[number]
+      `,
+        });
+        const enumss = Array.from(context.enumTypes)
+            .map(([types, key]) => `export const ${key} = [ ${types} ] as const; export type ${key} = typeof ${key}[number] `)
+            .join(";");
+        const enumFile = new Source({
+            path: generated("enums.ts"),
+            data: enumss,
+        });
+        const mockedFields = Array.from(context.mockedParams)
+            .map((paramName) => `${paramName} = $state<string | null>(null)`)
+            .join(";");
+        const mockedFile = new Source({
+            path: generated("mocked-params.svelte.ts"),
+            data: dedent `
+        class MockedParams {
+          ${mockedFields}
+        }
+
+        const mockedParams = new MockedParams()
+        export default mockedParams
+      `,
+        });
+        return [typesSrc, fieldsFile, enumFile, mockedFile];
+    }
+}

package/dist/core/generators/ApiCallStrategy.d.ts

@@ -0,0 +1,9 @@
+import type { CallMethodInput, CallStrategy } from "./CallStrategy.js";
+export declare class ApiCallStrategy implements CallStrategy {
+    readonly listStateAccess = "this.data";
+    buildSignature(method: CallMethodInput): string;
+    entityStateAccess(_method: CallMethodInput): string;
+    formStateAccess(_method: CallMethodInput): string;
+    private buildParamsType;
+    private buildPathsInfo;
+}