@ojiepermana/angular 22.1.10 → 22.1.12

package/sdk/src/emit/metadata.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operationRulesVarName = operationRulesVarName;
+exports.validationSchemasVarName = validationSchemasVarName;
+exports.emitMetadata = emitMetadata;
+const template_1 = require("../render/template");
+const OPERATION_RULES_AGGREGATE = 'apiOperationRules';
+const VALIDATION_SCHEMAS_AGGREGATE = 'apiValidationSchemas';
+/**
+ * A tag named `Api` (or a schema group like `ApiError`) camel-cases straight
+ * onto the aggregate names this emitter declares itself, which would make the
+ * aggregate file import, re-export and declare the same binding. A trailing
+ * underscore is unreachable from `camelCase`, so the fallback cannot collide
+ * with another group either.
+ */
+function groupVarName(group, suffix, aggregate) {
+    const name = `${(0, template_1.camelCase)(group) || 'shared'}${suffix}`;
+    return name === aggregate ? `${name}_` : name;
+}
+/** The exported binding holding one tag's operation rules. */
+function operationRulesVarName(tag) {
+    return groupVarName(tag, 'OperationRules', OPERATION_RULES_AGGREGATE);
+}
+/** The exported binding holding one schema group's validation rules. */
+function validationSchemasVarName(group) {
+    return groupVarName(group, 'ValidationSchemas', VALIDATION_SCHEMAS_AGGREGATE);
+}
+/**
+ * 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', OPERATION_RULES_AGGREGATE, operationRulesVarName)),
+    });
+    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', VALIDATION_SCHEMAS_AGGREGATE, validationSchemasVarName)),
+    });
+    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 ${operationRulesVarName(tag)}: 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 ${validationSchemasVarName(group)}: 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');
+}

package/sdk/src/emit/models.js

@@ -0,0 +1,104 @@
+"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' ? (0, template_1.quote)(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);
+        lines.push(`  ${(0, template_1.propertyKey)(propName)}${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' ? (0, template_1.quote)(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' ? (0, template_1.quote)(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 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/sdk/src/emit/navigation.js

@@ -0,0 +1,56 @@
+"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/sdk/src/emit/operations.js

@@ -0,0 +1,118 @@
+"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(${(0, template_1.quote)(p.name)}, params${(0, template_1.propertyAccess)(p.name)});`);
+    const queryCalls = op.params
+        .filter((p) => p.in === 'query')
+        .map((p) => `    rb.query(${(0, template_1.quote)(p.name)}, params${(0, template_1.propertyAccess)(p.name)});`);
+    const headerCalls = op.params
+        .filter((p) => p.in === 'header')
+        .map((p) => `    rb.header(${(0, template_1.quote)(p.name)}, params${(0, template_1.propertyAccess)(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, ${(0, template_1.quote)(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 = ${(0, template_1.quote)(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);
+        lines.push(`  ${(0, template_1.propertyKey)(p.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 };
+}

package/sdk/src/emit/public-api.js

@@ -0,0 +1,54 @@
+"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)}';`;
+}