@ojiepermana/angular 21.3.4 → 22.0.27

package/generator/api/bin/src/emit/metadata.js

@@ -1,295 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.emitMetadata = emitMetadata;
-const template_1 = require("../render/template");
-/**
- * Emit frontend-friendly metadata:
- *   - `metadata-types.ts`            shared rule types
- *   - `permissions/<tag>.ts`         operation rules (per tag) + `index.ts`
- *   - `validators/<tag>.ts`          schema validation rules (per tag) + `index.ts`
- *   - `metadata.ts`                  aggregate export
- *   - `openapi-helpers.ts`           small helpers (`getRequiredPermissions`, etc)
- */
-function emitMetadata(ir, target) {
-    const files = [];
-    files.push({ path: 'metadata-types.ts', content: (0, template_1.finalize)(metadataTypesFile(target)) });
-    const opsByTag = groupOps(ir.operations);
-    for (const [tag, ops] of opsByTag) {
-        files.push({
-            path: `permissions/${(0, template_1.kebabCase)(tag)}.ts`,
-            content: (0, template_1.finalize)(permissionFile(tag, ops, target)),
-        });
-    }
-    const permTags = Array.from(opsByTag.keys());
-    files.push({
-        path: 'permissions/index.ts',
-        content: (0, template_1.finalize)(buildAggregateFile(target, permTags, 'ApiOperationRule', 'apiOperationRules', (t) => `${toCamel(t)}OperationRules`)),
-    });
-    const schemasByPrefix = groupSchemas(ir.schemas);
-    for (const [group, schemas] of schemasByPrefix) {
-        files.push({
-            path: `validators/${(0, template_1.kebabCase)(group)}.ts`,
-            content: (0, template_1.finalize)(validatorFile(group, schemas, target)),
-        });
-    }
-    const valGroups = Array.from(schemasByPrefix.keys());
-    files.push({
-        path: 'validators/index.ts',
-        content: (0, template_1.finalize)(buildAggregateFile(target, valGroups, 'ApiSchemaRule', 'apiValidationSchemas', (g) => `${toCamel(g)}ValidationSchemas`)),
-    });
-    files.push({ path: 'metadata.ts', content: (0, template_1.finalize)(metadataFile(target)) });
-    files.push({ path: 'openapi-helpers.ts', content: (0, template_1.finalize)(helpersFile(target)) });
-    return files;
-}
-/**
- * Emit a per-feature `index.ts` that re-exports each per-tag module plus a
- * single aggregated record (`apiOperationRules`, `apiValidationSchemas`).
- */
-function buildAggregateFile(target, groups, typeName, aggregateName, varNameFor) {
-    const reexports = groups.map((g) => `export { ${varNameFor(g)} } from './${(0, template_1.kebabCase)(g)}';`).join('\n');
-    const imports = groups.map((g) => `import { ${varNameFor(g)} } from './${(0, template_1.kebabCase)(g)}';`).join('\n');
-    const spreads = groups.map((g) => `  ...${varNameFor(g)},`).join('\n');
-    return `${target.banner}
-
-import type { ${typeName} } from '../metadata-types';
-${imports}
-
-${reexports}
-
-export const ${aggregateName}: Record<string, ${typeName}> = {
-${spreads}
-};
-`;
-}
-function metadataTypesFile(target) {
-    return `${target.banner}
-
-export interface ApiFieldRule {
-  required?: boolean;
-  type?: string;
-  format?: string;
-  description?: string;
-  nullable?: boolean;
-  minLength?: number;
-  maxLength?: number;
-  minimum?: number;
-  maximum?: number;
-  pattern?: string;
-  enumValues?: readonly (string | number)[];
-  ref?: string;
-  itemsRef?: string;
-  itemsType?: string;
-}
-
-export interface ApiSchemaRule {
-  required: readonly string[];
-  properties: Record<string, ApiFieldRule>;
-}
-
-export interface ApiOperationRule {
-  method: string;
-  path: string;
-  tags: readonly string[];
-  summary?: string;
-  description?: string;
-  requiredPermissions: readonly string[];
-  authorizationNotes: readonly string[];
-  securitySchemes: readonly string[];
-  pathParams: Record<string, ApiFieldRule>;
-  queryParams: Record<string, ApiFieldRule>;
-  bodySchema?: string;
-  responseSchemas: Record<string, string | undefined>;
-}
-`;
-}
-function permissionFile(tag, ops, target) {
-    const entries = ops
-        .slice()
-        .sort((a, b) => a.operationId.localeCompare(b.operationId))
-        .map((op) => renderOperationRule(op));
-    return `${target.banner}
-
-import type { ApiOperationRule } from '../metadata-types';
-
-export const ${toCamel(tag)}OperationRules: Record<string, ApiOperationRule> = {
-${entries.join(',\n')},
-};
-`;
-}
-function renderOperationRule(op) {
-    const pathParams = {};
-    const queryParams = {};
-    for (const p of op.params) {
-        const rule = trimRule(p.rule, p.required);
-        if (p.in === 'path')
-            pathParams[p.name] = rule;
-        else if (p.in === 'query')
-            queryParams[p.name] = rule;
-    }
-    const obj = {
-        method: op.method.toUpperCase(),
-        path: op.path,
-        tags: op.tags,
-        summary: op.summary,
-        description: op.description,
-        requiredPermissions: op.requiredPermissions,
-        authorizationNotes: op.authorizationNotes,
-        securitySchemes: op.securitySchemes,
-        pathParams,
-        queryParams,
-        bodySchema: op.bodySchemaRef,
-        responseSchemas: op.responses,
-    };
-    return `  ${JSON.stringify(op.operationId)}: ${toInlineJson(obj, 2)}`;
-}
-function validatorFile(group, schemas, target) {
-    const entries = schemas
-        .slice()
-        .sort((a, b) => a.name.localeCompare(b.name))
-        .map((s) => renderSchemaRule(s));
-    return `${target.banner}
-
-import type { ApiSchemaRule } from '../metadata-types';
-
-export const ${toCamel(group)}ValidationSchemas: Record<string, ApiSchemaRule> = {
-${entries.join(',\n')},
-};
-`;
-}
-function renderSchemaRule(schema) {
-    const properties = {};
-    for (const [name, rule] of Object.entries(schema.properties)) {
-        properties[name] = trimRule(rule, rule.required === true);
-    }
-    const obj = {
-        required: schema.required,
-        properties,
-    };
-    return `  ${JSON.stringify(schema.name)}: ${toInlineJson(obj, 2)}`;
-}
-function metadataFile(target) {
-    return `${target.banner}
-
-export * from './metadata-types';
-export * from './permissions';
-export * from './validators';
-`;
-}
-function helpersFile(target) {
-    return `${target.banner}
-
-import { apiOperationRules, apiValidationSchemas } from './metadata';
-import type { ApiFieldRule, ApiOperationRule, ApiSchemaRule } from './metadata-types';
-
-export function getSchemaRule(schemaName: string): ApiSchemaRule | undefined {
-  return apiValidationSchemas[schemaName];
-}
-
-export function getFieldRule(schemaName: string, fieldName: string): ApiFieldRule | undefined {
-  return apiValidationSchemas[schemaName]?.properties[fieldName];
-}
-
-export function getOperationRule(operationId: string): ApiOperationRule | undefined {
-  return apiOperationRules[operationId];
-}
-
-export function getRequiredPermissions(operationId: string): readonly string[] {
-  return apiOperationRules[operationId]?.requiredPermissions ?? [];
-}
-
-export function hasRequiredPermissions(
-  operationId: string,
-  ownedPermissions: readonly string[],
-): boolean {
-  return getRequiredPermissions(operationId).every((p) => ownedPermissions.includes(p));
-}
-`;
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function groupOps(operations) {
-    const map = new Map();
-    for (const op of operations) {
-        const bucket = map.get(op.tag) ?? [];
-        bucket.push(op);
-        map.set(op.tag, bucket);
-    }
-    return map;
-}
-/**
- * Group schemas for validator output by a common prefix tag. We use a simple
- * heuristic: first PascalCase word of the schema name (e.g. `UserListResponse`
- * → `User`, `AuthTokenResponse` → `Auth`). Keeps file sizes small and mirrors
- * the reference layout.
- */
-function groupSchemas(schemas) {
-    const map = new Map();
-    for (const s of schemas) {
-        const prefix = detectSchemaGroup(s.name);
-        const bucket = map.get(prefix) ?? [];
-        bucket.push(s);
-        map.set(prefix, bucket);
-    }
-    return map;
-}
-function detectSchemaGroup(name) {
-    const match = name.match(/^([A-Z][a-z]+)/);
-    return match ? match[1] : 'Shared';
-}
-function trimRule(rule, required) {
-    const out = {};
-    if (required)
-        out.required = true;
-    else
-        out.required = false;
-    if (rule.type)
-        out.type = rule.type;
-    if (rule.format)
-        out.format = rule.format;
-    if (rule.description)
-        out.description = rule.description;
-    if (rule.nullable)
-        out.nullable = true;
-    if (typeof rule.minLength === 'number')
-        out.minLength = rule.minLength;
-    if (typeof rule.maxLength === 'number')
-        out.maxLength = rule.maxLength;
-    if (typeof rule.minimum === 'number')
-        out.minimum = rule.minimum;
-    if (typeof rule.maximum === 'number')
-        out.maximum = rule.maximum;
-    if (rule.pattern)
-        out.pattern = rule.pattern;
-    if (rule.enumValues && rule.enumValues.length)
-        out.enumValues = rule.enumValues;
-    if (rule.ref)
-        out.ref = rule.ref;
-    if (rule.itemsRef)
-        out.itemsRef = rule.itemsRef;
-    if (rule.itemsType)
-        out.itemsType = rule.itemsType;
-    return out;
-}
-/** Stable JSON output with stripped `undefined` values. */
-function toInlineJson(value, indent) {
-    const pretty = JSON.stringify(value, (_key, val) => (val === undefined ? undefined : val), 2);
-    if (!pretty)
-        return 'undefined';
-    return pretty
-        .split('\n')
-        .map((line, i) => (i === 0 ? line : ' '.repeat(indent) + line))
-        .join('\n');
-}
-function toCamel(input) {
-    const parts = String(input)
-        .replace(/[^a-zA-Z0-9]+/g, ' ')
-        .trim()
-        .split(/\s+/)
-        .filter(Boolean);
-    if (!parts.length)
-        return 'shared';
-    return parts
-        .map((w, i) => (i === 0 ? w[0].toLowerCase() + w.slice(1) : w[0].toUpperCase() + w.slice(1).toLowerCase()))
-        .join('');
-}

package/generator/api/bin/src/emit/models.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.emitModels = emitModels;
-exports.renderFieldType = renderFieldType;
-const template_1 = require("../render/template");
-/**
- * Emit one `interface` per schema into `models/<kebab>.ts` — type-only, no
- * runtime footprint.
- */
-function emitModels(ir, target) {
-    const files = [];
-    for (const schema of ir.schemas) {
-        const fileName = `${(0, template_1.kebabCase)(schema.name)}.ts`;
-        files.push({
-            path: `models/${fileName}`,
-            content: (0, template_1.finalize)(renderModel(schema, ir, target)),
-        });
-    }
-    return files;
-}
-function renderModel(schema, ir, target) {
-    const imports = collectModelImports(schema).filter((name) => name !== schema.name);
-    const importLines = imports.map((name) => `import type { ${name} } from './${(0, template_1.kebabCase)(name)}';`);
-    let body = '';
-    if (schema.enumValues) {
-        // Primitive enum alias.
-        body = `export type ${(0, template_1.pascalCase)(schema.name)} = ${schema.enumValues
-            .map((v) => (typeof v === 'string' ? `'${escapeSingle(v)}'` : String(v)))
-            .join(' | ')};`;
-    }
-    else if (schema.arrayItemRef || schema.arrayItemType) {
-        const itemType = schema.arrayItemRef ? (0, template_1.pascalCase)(schema.arrayItemRef) : tsPrimitive(schema.arrayItemType);
-        body = `export type ${(0, template_1.pascalCase)(schema.name)} = ${itemType}[];`;
-    }
-    else {
-        body = renderInterface(schema);
-    }
-    return [target.banner, '', ...importLines, importLines.length ? '' : '', body].join('\n');
-}
-function renderInterface(schema) {
-    const lines = [];
-    lines.push(`export interface ${(0, template_1.pascalCase)(schema.name)} {`);
-    for (const [propName, rule] of Object.entries(schema.properties)) {
-        const optional = rule.required ? '' : '?';
-        const type = renderFieldType(rule);
-        const safeName = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(propName) ? propName : `'${propName}'`;
-        lines.push(`  ${safeName}${optional}: ${type};`);
-    }
-    lines.push(`}`);
-    return lines.join('\n');
-}
-function renderFieldType(rule) {
-    let base;
-    if (rule.ref) {
-        base = (0, template_1.pascalCase)(rule.ref);
-    }
-    else if (rule.type === 'array') {
-        const item = rule.itemsRef
-            ? (0, template_1.pascalCase)(rule.itemsRef)
-            : rule.enumValues
-                ? rule.enumValues.map((v) => (typeof v === 'string' ? `'${escapeSingle(v)}'` : String(v))).join(' | ')
-                : tsPrimitive(rule.itemsType);
-        base = rule.enumValues && !rule.itemsRef ? `(${item})[]` : `${item}[]`;
-    }
-    else if (rule.enumValues && rule.enumValues.length > 0) {
-        base = rule.enumValues.map((v) => (typeof v === 'string' ? `'${escapeSingle(v)}'` : String(v))).join(' | ');
-    }
-    else {
-        base = tsPrimitive(rule.type);
-    }
-    return rule.nullable ? `${base} | null` : base;
-}
-function tsPrimitive(type) {
-    switch (type) {
-        case 'string':
-            return 'string';
-        case 'integer':
-        case 'number':
-            return 'number';
-        case 'boolean':
-            return 'boolean';
-        case 'array':
-            return 'unknown[]';
-        case 'object':
-            return 'Record<string, unknown>';
-        case undefined:
-        case 'unknown':
-        default:
-            return 'unknown';
-    }
-}
-function escapeSingle(value) {
-    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-}
-function collectModelImports(schema) {
-    const set = new Set();
-    if (schema.arrayItemRef)
-        set.add(schema.arrayItemRef);
-    for (const rule of Object.values(schema.properties)) {
-        if (rule.ref)
-            set.add(rule.ref);
-        if (rule.itemsRef)
-            set.add(rule.itemsRef);
-    }
-    return [...set].sort();
-}

package/generator/api/bin/src/emit/navigation.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.emitNavigation = emitNavigation;
-const template_1 = require("../render/template");
-/**
- * Emit `api.navigation.ts` exporting `NavigationItem[]` data that plugs
- * directly into `NavigationService.registerItems(...)` from
- * `@ojiepermana/angular/navigation`.
- */
-function emitNavigation(ir, target) {
-    return [
-        {
-            path: 'api.navigation.ts',
-            content: (0, template_1.finalize)(renderNavigation(ir.navigation, target)),
-        },
-    ];
-}
-function renderNavigation(nodes, target) {
-    return `${target.banner}
-
-import type { NavigationItem } from '@ojiepermana/angular/navigation/types';
-
-export const ApiNavigation: NavigationItem[] = ${stringifyNodes(nodes, 0, [])};
-`;
-}
-function stringifyNodes(nodes, depth, lineage) {
-    if (!nodes.length)
-        return '[]';
-    const pad = '  '.repeat(depth + 1);
-    const closePad = '  '.repeat(depth);
-    return `[\n${nodes
-        .map((node) => pad + stringifyNode(node, depth + 1, [...lineage, node.name]))
-        .join(',\n')},\n${closePad}]`;
-}
-function stringifyNode(node, depth, lineage) {
-    const hasChildren = node.children.length > 0;
-    const pad = '  '.repeat(depth + 1);
-    const closePad = '  '.repeat(depth);
-    const fields = [
-        `${pad}id: ${JSON.stringify(lineage.map(template_1.kebabCase).filter(Boolean).join('-'))}`,
-        `${pad}title: ${JSON.stringify(node.name)}`,
-        `${pad}type: ${JSON.stringify(resolveItemType(lineage.length - 1, hasChildren))}`,
-    ];
-    if (node.description)
-        fields.push(`${pad}subtitle: ${JSON.stringify(node.description)}`);
-    if (node.xIcon)
-        fields.push(`${pad}icon: ${JSON.stringify(node.xIcon)}`);
-    if (hasChildren)
-        fields.push(`${pad}children: ${stringifyNodes(node.children, depth + 1, lineage)}`);
-    return `{\n${fields.join(',\n')},\n${closePad}}`;
-}
-function resolveItemType(depth, hasChildren) {
-    if (!hasChildren)
-        return 'basic';
-    return depth === 0 ? 'group' : 'collapsable';
-}

package/generator/api/bin/src/emit/operations.js

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.emitOperations = emitOperations;
-const template_1 = require("../render/template");
-const models_1 = require("./models");
-/**
- * Emit one tree-shakeable operation function per operationId at
- * `fn/<tag-kebab>/<operation-kebab>.ts`.
- *
- * Each file exports:
- *   - `<operationId>$Params` interface
- *   - `<operationId>` function returning `Observable<StrictHttpResponse<R>>`
- *   - `<operationId>.PATH` constant
- */
-function emitOperations(ir, target) {
-    return ir.operations.map((op) => ({
-        path: `fn/${(0, template_1.kebabCase)(op.tag)}/${(0, template_1.kebabCase)(op.operationId)}.ts`,
-        content: (0, template_1.finalize)(renderOperation(op, target)),
-    }));
-}
-function renderOperation(op, target) {
-    const fnName = (0, template_1.camelCase)(op.operationId);
-    const paramsName = `${(0, template_1.pascalCase)(op.operationId)}$Params`;
-    const responseType = op.successRef ? (0, template_1.pascalCase)(op.successRef) : 'unknown';
-    const paramImports = collectParamImports(op);
-    const imports = [
-        `import { HttpClient, HttpContext, HttpResponse } from '@angular/common/http';`,
-        `import { Observable } from 'rxjs';`,
-        `import { filter, map } from 'rxjs/operators';`,
-        ``,
-        `import { RequestBuilder } from '../../request-builder';`,
-        `import { StrictHttpResponse } from '../../strict-http-response';`,
-    ];
-    for (const name of paramImports) {
-        imports.push(`import type { ${(0, template_1.pascalCase)(name)} } from '../../models/${(0, template_1.kebabCase)(name)}';`);
-    }
-    const paramsInterface = renderParamsInterface(op, paramsName);
-    const hasAnyParams = paramsInterface.hasAnyField;
-    const paramsOptional = !paramsInterface.anyRequired;
-    const bodyCT = op.bodySchemaRef ? "'application/json'" : '';
-    const pathCalls = op.params
-        .filter((p) => p.in === 'path')
-        .map((p) => `    rb.path('${p.name}', params.${safeProp(p.name)});`);
-    const queryCalls = op.params
-        .filter((p) => p.in === 'query')
-        .map((p) => `    rb.query('${p.name}', params.${safeProp(p.name)});`);
-    const headerCalls = op.params
-        .filter((p) => p.in === 'header')
-        .map((p) => `    rb.header('${p.name}', params.${safeProp(p.name)});`);
-    const bodyCall = op.bodySchemaRef ? `    rb.body(params.body, ${bodyCT});` : '';
-    const populate = pathCalls.length || queryCalls.length || headerCalls.length || bodyCall
-        ? `  if (params) {
-${[...pathCalls, ...queryCalls, ...headerCalls, bodyCall].filter(Boolean).join('\n')}
-  }`
-        : '';
-    const paramsArg = hasAnyParams
-        ? `params${paramsOptional ? '?' : ''}: ${paramsName}`
-        : `_params?: Record<string, never>`;
-    return `${target.banner}
-
-${imports.join('\n')}
-
-${paramsInterface.source}
-export function ${fnName}(
-  http: HttpClient,
-  rootUrl: string,
-  ${paramsArg},
-  context?: HttpContext,
-): Observable<StrictHttpResponse<${responseType}>> {
-  const rb = new RequestBuilder(rootUrl, ${fnName}.PATH, '${op.method}');
-${populate}
-  return http.request(rb.build({ responseType: 'json', accept: 'application/json', context })).pipe(
-    filter((r: unknown): r is HttpResponse<unknown> => r instanceof HttpResponse),
-    map((r) => r as StrictHttpResponse<${responseType}>),
-  );
-}
-
-${fnName}.PATH = '${op.path}';
-`;
-}
-function collectParamImports(op) {
-    const set = new Set();
-    for (const p of op.params) {
-        if (p.rule.ref)
-            set.add(p.rule.ref);
-        if (p.rule.itemsRef)
-            set.add(p.rule.itemsRef);
-    }
-    if (op.bodySchemaRef)
-        set.add(op.bodySchemaRef);
-    if (op.successRef)
-        set.add(op.successRef);
-    return [...set].sort();
-}
-function renderParamsInterface(op, paramsName) {
-    const lines = [];
-    let anyRequired = false;
-    const pushField = (p) => {
-        const optional = p.required ? '' : '?';
-        if (p.required)
-            anyRequired = true;
-        const type = (0, models_1.renderFieldType)(p.rule);
-        const name = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(p.name) ? p.name : `'${p.name}'`;
-        lines.push(`  ${name}${optional}: ${type};`);
-    };
-    for (const p of op.params)
-        pushField(p);
-    if (op.bodySchemaRef) {
-        const optional = op.bodyRequired ? '' : '?';
-        if (op.bodyRequired)
-            anyRequired = true;
-        lines.push(`  body${optional}: ${(0, template_1.pascalCase)(op.bodySchemaRef)};`);
-    }
-    const hasAnyField = lines.length > 0;
-    const source = hasAnyField
-        ? `export interface ${paramsName} {\n${lines.join('\n')}\n}\n`
-        : `export type ${paramsName} = Record<string, never>;\n`;
-    return { source, hasAnyField, anyRequired };
-}
-function safeProp(name) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : `['${name}']`;
-}

package/generator/api/bin/src/emit/public-api.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.emitPublicApi = emitPublicApi;
-const template_1 = require("../render/template");
-/**
- * Emit `public-api.ts` — the barrel that re-exports every generated artifact
- * based on the resolved feature flags. Mirrors the convention used by the
- * reference output in `old/api/index.ts`.
- */
-function emitPublicApi(ir, target) {
-    const lines = [target.banner, ''];
-    if (target.features.client) {
-        lines.push(`export { ApiConfiguration, provideApiConfiguration } from './api-configuration';`);
-        lines.push(`export { BaseService } from './base-service';`);
-        lines.push(`export { RequestBuilder } from './request-builder';`);
-        lines.push(`export type { StrictHttpResponse } from './strict-http-response';`);
-        lines.push(`export { ${target.clientName} } from './api';`);
-        lines.push('');
-    }
-    if (target.features.models) {
-        for (const schema of ir.schemas) {
-            lines.push(`export type { ${(0, template_1.pascalCase)(schema.name)} } from './models/${(0, template_1.kebabCase)(schema.name)}';`);
-        }
-        lines.push('');
-    }
-    if (target.features.services) {
-        const tags = Array.from(new Set(ir.operations.map((o) => o.tag))).sort();
-        for (const tag of tags) {
-            lines.push(`export { ${(0, template_1.pascalCase)(tag)}Service } from './services/${(0, template_1.kebabCase)(tag)}.service';`);
-        }
-        lines.push('');
-    }
-    if (target.features.operations) {
-        const sorted = [...ir.operations].sort((a, b) => a.operationId.localeCompare(b.operationId));
-        for (const op of sorted) {
-            lines.push(renderFnReexport(op));
-        }
-        lines.push('');
-    }
-    if (target.features.metadata) {
-        lines.push(`export * from './metadata';`);
-        lines.push(`export * from './openapi-helpers';`);
-        lines.push('');
-    }
-    if (target.features.navigation) {
-        lines.push(`export { ApiNavigation } from './api.navigation';`);
-    }
-    return [{ path: 'public-api.ts', content: (0, template_1.finalize)(lines.join('\n')) }];
-}
-function renderFnReexport(op) {
-    const fnName = (0, template_1.camelCase)(op.operationId);
-    const paramsName = `${(0, template_1.pascalCase)(op.operationId)}$Params`;
-    return `export { ${fnName}, type ${paramsName} } from './fn/${(0, template_1.kebabCase)(op.tag)}/${(0, template_1.kebabCase)(op.operationId)}';`;
-}