@lssm/bundle.contractspec-workspace 0.0.0-canary-20251217083314 → 1.41.1

package/dist/modules/contractspec-workspace/dist/templates/experiment.js

@@ -1,87 +0,0 @@
-import { toPascalCase } from "./utils.js";
-
-//#region ../../modules/contractspec-workspace/dist/templates/experiment.js
-function generateExperimentSpec(data) {
-	const specVar = toPascalCase(data.name.split(".").pop() ?? "Experiment") + "Experiment";
-	const variants = data.variants.map((variant) => {
-		const overrides = variant.overrides?.length ? `      overrides: [
-${variant.overrides.map((override) => `        {
-          type: '${override.type}',
-          target: '${escapeString(override.target)}',
-          ${typeof override.version === "number" ? `version: ${override.version},` : ""}
-        }`).join(",\n")}
-      ],` : "";
-		return `    {
-      id: '${escapeString(variant.id)}',
-      name: '${escapeString(variant.name)}',
-      ${variant.description ? `description: '${escapeString(variant.description)}',` : ""}
-      ${typeof variant.weight === "number" ? `weight: ${variant.weight},` : ""}
-${overrides}
-    }`;
-	}).join(",\n");
-	const allocation = renderAllocation(data.allocation);
-	const metrics = data.successMetrics?.length ? `  successMetrics: [
-${data.successMetrics.map((metric) => `    {
-      name: '${escapeString(metric.name)}',
-      telemetryEvent: { name: '${escapeString(metric.eventName)}', version: ${metric.eventVersion} },
-      aggregation: '${metric.aggregation}',
-      ${typeof metric.target === "number" ? `target: ${metric.target},` : ""}
-    }`).join(",\n")}
-  ],` : "";
-	return `import type { ExperimentSpec } from '@lssm/lib.contracts/experiments';
-
-export const ${specVar}: ExperimentSpec = {
-  meta: {
-    name: '${escapeString(data.name)}',
-    version: ${data.version},
-    title: '${escapeString(data.name)} experiment',
-    description: '${escapeString(data.description || "Describe the experiment goal.")}',
-    domain: '${escapeString(data.domain)}',
-    owners: [${data.owners.map((owner) => `'${escapeString(owner)}'`).join(", ")}],
-    tags: [${data.tags.map((tag) => `'${escapeString(tag)}'`).join(", ")}],
-    stability: '${data.stability}',
-  },
-  controlVariant: '${escapeString(data.controlVariant)}',
-  variants: [
-${variants}
-  ],
-  allocation: ${allocation},
-${metrics}
-};
-`;
-}
-function renderAllocation(allocation) {
-	switch (allocation.type) {
-		case "random": return `{
-    type: 'random',
-    ${allocation.salt ? `salt: '${escapeString(allocation.salt)}',` : ""}
-  }`;
-		case "sticky": return `{
-    type: 'sticky',
-    attribute: '${allocation.attribute}',
-    ${allocation.salt ? `salt: '${escapeString(allocation.salt)}',` : ""}
-  }`;
-		case "targeted": return `{
-    type: 'targeted',
-    rules: [
-${allocation.rules.map((rule) => `      {
-        variantId: '${escapeString(rule.variantId)}',
-        ${typeof rule.percentage === "number" ? `percentage: ${rule.percentage},` : ""}
-        ${rule.policy ? `policy: { name: '${escapeString(rule.policy.name)}'${typeof rule.policy.version === "number" ? `, version: ${rule.policy.version}` : ""} },` : ""}
-        ${rule.expression ? `expression: '${escapeString(rule.expression)}',` : ""}
-      }`).join(",\n")}
-    ],
-    fallback: '${allocation.fallback ?? "control"}',
-  }`;
-		default: return renderUnsupportedAllocation(allocation);
-	}
-}
-function escapeString(value) {
-	return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-function renderUnsupportedAllocation(allocation) {
-	throw new Error(`Unsupported allocation type ${allocation}`);
-}
-
-//#endregion
-export { generateExperimentSpec };

package/dist/modules/contractspec-workspace/dist/templates/handler.js

@@ -1,95 +0,0 @@
-import { toCamelCase, toKebabCase, toPascalCase } from "./utils.js";
-
-//#region ../../modules/contractspec-workspace/dist/templates/handler.js
-/**
-* Handler and component template generation.
-* Extracted from cli-contracts/src/templates/handler.template.ts
-*/
-/**
-* Generate handler implementation template.
-*/
-function generateHandlerTemplate(specName, kind) {
-	const handlerName = toCamelCase(specName.split(".").pop() ?? "unknown") + "Handler";
-	const specVarName = toPascalCase(specName.split(".").pop() ?? "Unknown") + "Spec";
-	return `import type { ContractHandler } from '@lssm/lib.contracts';
-import { ${specVarName} } from '../contracts/${toKebabCase(specName)}.contracts';
-
-/**
- * Handler for ${specName}
- */
-export const ${handlerName}: ContractHandler<typeof ${specVarName}> = async (
-  input,
-  context
-) => {
-  // TODO: Implement ${kind} logic
-  
-  try {
-    // 1. Validate prerequisites
-    // 2. Perform business logic
-    // 3. Emit events if needed
-    // 4. Return result
-    
-    return {
-      ok: true,
-    };
-  } catch (error) {
-    // Handle and map errors to spec.io.errors
-    throw error;
-  }
-};
-`;
-}
-/**
-* Generate React component template.
-*/
-function generateComponentTemplate(componentName, description) {
-	const pascalName = toPascalCase(componentName);
-	return `import React from 'react';
-
-interface ${pascalName}Props {
-  // TODO: Define props based on presentation spec
-}
-
-/**
- * ${description}
- */
-export const ${pascalName}: React.FC<${pascalName}Props> = (props) => {
-  return (
-    <div>
-      {/* TODO: Implement component UI */}
-      <p>Component: ${pascalName}</p>
-    </div>
-  );
-};
-`;
-}
-/**
-* Generate test template.
-*/
-function generateTestTemplate(targetName, type) {
-	const importPath = type === "handler" ? "../handlers" : "../components";
-	const testName = toPascalCase(targetName);
-	return `import { describe, it, expect } from 'bun:test';
-import { ${testName} } from '${importPath}/${toKebabCase(targetName)}';
-
-describe('${testName}', () => {
-  it('should ${type === "handler" ? "handle valid input" : "render correctly"}', async () => {
-    // TODO: Implement test
-    expect(true).toBe(true);
-  });
-
-  it('should handle edge cases', async () => {
-    // TODO: Test edge cases
-  });
-
-  ${type === "handler" ? `it('should handle errors appropriately', async () => {
-    // TODO: Test error scenarios
-  });` : `it('should be accessible', async () => {
-    // TODO: Test accessibility
-  });`}
-});
-`;
-}
-
-//#endregion
-export { generateComponentTemplate, generateHandlerTemplate, generateTestTemplate };

package/dist/modules/contractspec-workspace/dist/templates/integration-utils.js

@@ -1,104 +0,0 @@
-//#region ../../modules/contractspec-workspace/dist/templates/integration-utils.js
-function renderConfigSchema(fields) {
-	const requiredFields = fields.filter((field) => field.required);
-	return `    schema: {
-      type: 'object',
-${requiredFields.length > 0 ? `      required: [${requiredFields.map((field) => `'${field.key}'`).join(", ")}],
-` : ""}      properties: {
-${(fields.length ? fields.map((field) => {
-		const description = field.description ? `, description: '${escape(field.description)}'` : "";
-		return `        ${field.key}: { type: '${mapConfigType(field.type)}'${description} }`;
-	}).join(",\n") : "") || "      "}
-      },
-    },\n`;
-}
-function renderSecretSchema(fields) {
-	const requiredFields = fields.filter((field) => field.required);
-	return `    schema: {
-      type: 'object',
-${requiredFields.length > 0 ? `      required: [${requiredFields.map((field) => `'${field.key}'`).join(", ")}],
-` : ""}      properties: {
-${(fields.length ? fields.map((field) => {
-		const description = field.description ? `, description: '${escape(field.description)}'` : "";
-		return `        ${field.key}: { type: 'string'${description} }`;
-	}).join(",\n") : "") || "      "}
-      },
-    },\n`;
-}
-function renderConfigExample(fields) {
-	if (fields.length === 0) return `{}`;
-	return `{
-${fields.map((field) => {
-		switch (field.type) {
-			case "number": return `    ${field.key}: 0`;
-			case "boolean": return `    ${field.key}: true`;
-			case "string":
-			default: return `    ${field.key}: '${field.key.toUpperCase()}_VALUE'`;
-		}
-	}).join(",\n")}
-  }`;
-}
-function renderSecretExample(fields) {
-	if (fields.length === 0) return `{}`;
-	return `{
-${fields.map((field) => `    ${field.key}: '${field.key.toUpperCase()}_SECRET'`).join(",\n")}
-  }`;
-}
-function renderConstraints(rpm, rph) {
-	if (rpm == null && rph == null) return "";
-	const entries = [];
-	if (rpm != null) entries.push(`      rpm: ${rpm}`);
-	if (rph != null) entries.push(`      rph: ${rph}`);
-	return `  constraints: {
-    rateLimit: {
-${entries.join(",\n")}
-    },
-  },
-`;
-}
-function renderByokSetup(modes, instructions, scopes) {
-	if (!modes.includes("byok")) return "";
-	const instructionsLine = instructions ? `    setupInstructions: '${escape(instructions)}',\n` : "";
-	const scopesLine = scopes && scopes.length ? `    requiredScopes: [${scopes.map((scope) => `'${escape(scope)}'`).join(", ")}],\n` : "";
-	if (!instructionsLine && !scopesLine) return "";
-	return `  byokSetup: {
-${instructionsLine}${scopesLine}  },
-`;
-}
-function mapConfigType(type) {
-	switch (type) {
-		case "number": return "number";
-		case "boolean": return "boolean";
-		case "string":
-		default: return "string";
-	}
-}
-function stabilityToEnum(stability) {
-	switch (stability) {
-		case "beta": return "Beta";
-		case "stable": return "Stable";
-		case "deprecated": return "Deprecated";
-		case "experimental":
-		default: return "Experimental";
-	}
-}
-function renderProvides(data) {
-	return data.capabilitiesProvided.map((cap) => `      { key: '${cap.key}', version: ${cap.version} }`).join(",\n");
-}
-function renderRequires(data) {
-	if (data.capabilitiesRequired.length === 0) return "";
-	return `    requires: [
-${data.capabilitiesRequired.map((req) => {
-		const version = typeof req.version === "number" ? `, version: ${req.version}` : "";
-		const optional = req.optional ? ", optional: true" : "";
-		const reason = req.reason ? `, reason: '${escape(req.reason)}'` : "";
-		return `      { key: '${req.key}'${version}${optional}${reason} }`;
-	}).join(",\n")}
-    ],`;
-}
-function escape(value) {
-	return value.replace(/`/g, "\\`").replace(/'/g, "\\'");
-}
-
-//#endregion
-export { escape, renderByokSetup, renderConfigExample, renderConfigSchema, renderConstraints, renderProvides, renderRequires, renderSecretExample, renderSecretSchema, stabilityToEnum };

package/dist/modules/contractspec-workspace/dist/templates/integration.js

@@ -1,62 +0,0 @@
-import { toPascalCase } from "./utils.js";
-import { escape, renderByokSetup, renderConfigExample, renderConfigSchema, renderConstraints, renderProvides, renderRequires, renderSecretExample, renderSecretSchema, stabilityToEnum } from "./integration-utils.js";
-
-//#region ../../modules/contractspec-workspace/dist/templates/integration.js
-function generateIntegrationSpec(data) {
-	const specName = toPascalCase(data.name.split(".").pop() ?? "Integration");
-	const varName = `${specName}IntegrationSpec`;
-	const registerFn = `register${specName}Integration`;
-	const supportedModes = data.supportedModes.length ? data.supportedModes : ["managed"];
-	const supportedModesLine = supportedModes.map((mode) => `'${mode}'`).join(", ");
-	const provides = renderProvides(data);
-	const requires = renderRequires(data);
-	const configSchema = renderConfigSchema(data.configFields);
-	const configExample = renderConfigExample(data.configFields);
-	const secretSchema = renderSecretSchema(data.secretFields);
-	const secretExample = renderSecretExample(data.secretFields);
-	const docsUrl = data.docsUrl ? `  docsUrl: '${escape(data.docsUrl)}',\n` : "";
-	const constraints = renderConstraints(data.rateLimitRpm, data.rateLimitRph);
-	const byokSetup = renderByokSetup(supportedModes, data.byokSetupInstructions, data.byokRequiredScopes);
-	return `import { StabilityEnum } from '@lssm/lib.contracts/ownership';
-import type { IntegrationSpec } from '@lssm/lib.contracts/integrations/spec';
-import type { IntegrationSpecRegistry } from '@lssm/lib.contracts/integrations/spec';
-
-export const ${varName}: IntegrationSpec = {
-  meta: {
-    key: '${escape(data.name)}',
-    version: ${data.version},
-    category: '${data.category}',
-    displayName: '${escape(data.displayName)}',
-    title: '${escape(data.title)}',
-    description: '${escape(data.description)}',
-    domain: '${escape(data.domain)}',
-    owners: [${data.owners.map((owner) => `'${escape(owner)}'`).join(", ")}],
-    tags: [${data.tags.map((tag) => `'${escape(tag)}'`).join(", ")}],
-    stability: StabilityEnum.${stabilityToEnum(data.stability)},
-  },
-  supportedModes: [${supportedModesLine}],
-  capabilities: {
-    provides: [
-${provides}
-    ],
-${requires.length > 0 ? `${requires}\n` : ""}  },
-  configSchema: {
-${configSchema}    example: ${configExample},
-  },
-  secretSchema: {
-${secretSchema}    example: ${secretExample},
-  },
-${docsUrl}${constraints}${byokSetup}  healthCheck: {
-    method: '${data.healthCheckMethod}',
-    timeoutMs: ${data.healthCheckTimeoutMs ?? 5e3},
-  },
-};
-
-export function ${registerFn}(registry: IntegrationSpecRegistry): IntegrationSpecRegistry {
-  return registry.register(${varName});
-}
-`;
-}
-
-//#endregion
-export { generateIntegrationSpec };

package/dist/modules/contractspec-workspace/dist/templates/knowledge.js

@@ -1,68 +0,0 @@
-import { escapeString, toPascalCase } from "./utils.js";
-
-//#region ../../modules/contractspec-workspace/dist/templates/knowledge.js
-function generateKnowledgeSpaceSpec(data) {
-	const specName = toPascalCase(data.name.split(".").pop() ?? "KnowledgeSpace");
-	const varName = `${specName}KnowledgeSpace`;
-	const registerFn = `register${specName}KnowledgeSpace`;
-	const retention = renderRetention(data);
-	const access = renderAccess(data);
-	const indexing = renderIndexing(data);
-	const policyComment = data.policyName && !data.policyVersion ? ` // defaults to latest version` : "";
-	return `import { StabilityEnum } from '@lssm/lib.contracts/ownership';
-import type { KnowledgeSpaceSpec } from '@lssm/lib.contracts/knowledge/spec';
-import type { KnowledgeSpaceRegistry } from '@lssm/lib.contracts/knowledge/spec';
-
-export const ${varName}: KnowledgeSpaceSpec = {
-  meta: {
-    key: '${escapeString(data.name)}',
-    version: ${data.version},
-    category: '${data.category}',
-    displayName: '${escape(data.displayName)}',
-    title: '${escape(data.title)}',
-    description: '${escape(data.description)}',
-    domain: '${escape(data.domain)}',
-    owners: [${data.owners.map((owner) => `'${escapeString(owner)}'`).join(", ")}],
-    tags: [${data.tags.map((tag) => `'${escapeString(tag)}'`).join(", ")}],
-    stability: StabilityEnum.${stabilityToEnum(data.stability)},
-  },
-  retention: ${retention},
-  access: {
-${access}${data.policyName ? `    policy: { name: '${escapeString(data.policyName)}',${data.policyVersion ? ` version: ${data.policyVersion}` : ""} },${policyComment}\n` : ""}  },
-${indexing}  description: '${escape(data.description || data.displayName)}',
-};
-
-export function ${registerFn}(registry: KnowledgeSpaceRegistry): KnowledgeSpaceRegistry {
-  return registry.register(${varName});
-}
-`;
-}
-function renderRetention(data) {
-	return `{ ttlDays: ${data.retention.ttlDays === null ? "null" : typeof data.retention.ttlDays === "number" ? String(data.retention.ttlDays) : "null"}${typeof data.retention.archiveAfterDays === "number" ? `, archiveAfterDays: ${data.retention.archiveAfterDays}` : ""} }`;
-}
-function renderAccess(data) {
-	return `${`    trustLevel: '${data.trustLevel}',\n`}${`    automationWritable: ${data.automationWritable},\n`}`;
-}
-function renderIndexing(data) {
-	const entries = [];
-	if (data.embeddingModel) entries.push(`    embeddingModel: '${escape(data.embeddingModel)}'`);
-	if (typeof data.chunkSize === "number") entries.push(`    chunkSize: ${data.chunkSize}`);
-	if (data.vectorDbIntegration) entries.push(`    vectorDbIntegration: '${escape(data.vectorDbIntegration)}'`);
-	if (entries.length === 0) return "";
-	return `  indexing: {\n${entries.join(",\n")}\n  },\n`;
-}
-function stabilityToEnum(stability) {
-	switch (stability) {
-		case "beta": return "Beta";
-		case "stable": return "Stable";
-		case "deprecated": return "Deprecated";
-		case "experimental":
-		default: return "Experimental";
-	}
-}
-function escape(value) {
-	return value.replace(/`/g, "\\`").replace(/'/g, "\\'");
-}
-
-//#endregion
-export { generateKnowledgeSpaceSpec };

package/dist/modules/contractspec-workspace/dist/templates/migration.js

@@ -1,60 +0,0 @@
-import { escapeString, toPascalCase } from "./utils.js";
-
-//#region ../../modules/contractspec-workspace/dist/templates/migration.js
-function generateMigrationSpec(data) {
-	const migrationVar = `${toPascalCase(data.name.split(".").pop() ?? "Migration")}Migration`;
-	const dependencies = data.dependencies.length > 0 ? `dependencies: [${data.dependencies.map((dep) => `'${escapeString(dep)}'`).join(", ")}],` : "";
-	return `import type { MigrationSpec } from '@lssm/lib.contracts/migrations';
-
-export const ${migrationVar}: MigrationSpec = {
-  meta: {
-    name: '${escapeString(data.name)}',
-    version: ${data.version},
-    title: '${escape(data.title)}',
-    description: '${escape(data.description ?? "")}',
-    domain: '${escape(data.domain)}',
-    owners: [${data.owners.map((owner) => `'${escapeString(owner)}'`).join(", ")}],
-    tags: [${data.tags.map((tag) => `'${escapeString(tag)}'`).join(", ")}],
-    stability: '${data.stability}',
-  },
-  plan: {
-    up: [
-${renderSteps(data.up)}
-    ],${data.down && data.down.length ? `
-    down: [
-${renderSteps(data.down)}
-    ],` : ""}
-  },
-  ${dependencies}
-};
-`;
-}
-function renderSteps(steps) {
-	return steps.map((step) => {
-		const description = step.description ? `description: '${escape(step.description)}',` : "";
-		switch (step.kind) {
-			case "schema": return `      {
-        kind: 'schema',
-        ${description}
-        sql: \`${escape(step.sql ?? "")}\`,
-      }`;
-			case "data": return `      {
-        kind: 'data',
-        ${description}
-        script: \`${escape(step.script ?? "")}\`,
-      }`;
-			case "validation":
-			default: return `      {
-        kind: 'validation',
-        ${description}
-        assertion: \`${escape(step.assertion ?? "")}\`,
-      }`;
-		}
-	}).join(",\n");
-}
-function escape(value) {
-	return value.replace(/`/g, "\\`").replace(/'/g, "\\'");
-}
-
-//#endregion
-export { generateMigrationSpec };

package/dist/modules/contractspec-workspace/dist/templates/operation.js

@@ -1,100 +0,0 @@
-import { capitalize, toPascalCase } from "./utils.js";
-
-//#region ../../modules/contractspec-workspace/dist/templates/operation.js
-/**
-* Generate operation spec TypeScript code.
-*/
-function generateOperationSpec(data) {
-	const { name, version, kind, description, goal, context, stability, owners, tags, auth, flags } = data;
-	const specVarName = toPascalCase(name.split(".").pop() ?? "Unknown") + "Spec";
-	const inputSchemaName = specVarName.replace("Spec", "Input");
-	const outputSchemaName = specVarName.replace("Spec", "Output");
-	return `import { define${capitalize(kind)} } from '@lssm/lib.contracts';
-import { ScalarTypeEnum, SchemaModel } from '@lssm/lib.schema';
-
-// TODO: Define input schema
-export const ${inputSchemaName} = new SchemaModel({
-  name: '${inputSchemaName}',
-  description: 'Input for ${name}',
-  fields: {
-    // Add your fields here
-    // example: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-  },
-});
-
-// TODO: Define output schema
-export const ${outputSchemaName} = new SchemaModel({
-  name: '${outputSchemaName}',
-  description: 'Output for ${name}',
-  fields: {
-    // Add your fields here
-    ok: { type: ScalarTypeEnum.Boolean(), isOptional: false },
-  },
-});
-
-export const ${specVarName} = define${capitalize(kind)}({
-  meta: {
-    name: '${name}',
-    version: ${version},
-    stability: '${stability}',
-    owners: [${owners.map((o) => `'${o}'`).join(", ")}],
-    tags: [${tags.map((t) => `'${t}'`).join(", ")}],
-    description: '${description}',
-    goal: '${goal}',
-    context: '${context}',
-  },
-
-  io: {
-    input: ${inputSchemaName},
-    output: ${outputSchemaName},
-    errors: {
-      // Define possible errors
-      // EXAMPLE_ERROR: {
-      //   description: 'Example error description',
-      //   http: 400,
-      //   when: 'When this error occurs',
-      // },
-    },
-  },
-
-  policy: {
-    auth: '${auth}',
-    ${flags.length > 0 ? `flags: [${flags.map((f) => `'${f}'`).join(", ")}],` : "// flags: [],"}
-  },
-
-  sideEffects: {
-    ${data.emitsEvents ? "emits: [\n      // Define events to emit\n      // { ref: SomeEventSpec, when: 'always' }\n    ]," : "// emits: [],"}
-    analytics: [
-      // Define analytics events
-    ],
-  },
-
-  transport: {
-    rest: { method: '${kind === "command" ? "POST" : "GET"}' },
-    gql: { field: '${name.replace(/\./g, "_")}' },
-    mcp: { toolName: '${name}.v${version}' },
-  },
-
-  acceptance: {
-    scenarios: [
-      {
-        name: 'Happy path',
-        given: ['preconditions'],
-        when: ['action taken'],
-        then: ['expected outcome'],
-      },
-    ],
-    examples: [
-      {
-        name: 'Example usage',
-        input: { /* example input */ },
-        output: { ok: true },
-      },
-    ],
-  },
-});
-`;
-}
-
-//#endregion
-export { generateOperationSpec };

package/dist/modules/contractspec-workspace/dist/templates/presentation.js

@@ -1,78 +0,0 @@
-import { toPascalCase } from "./utils.js";
-
-//#region ../../modules/contractspec-workspace/dist/templates/presentation.js
-/**
-* Generate presentation spec TypeScript code.
-*/
-function generatePresentationSpec(data) {
-	const { name, version, description, stability, owners, tags, presentationKind } = data;
-	const varName = toPascalCase(name.replace(/\./g, "_")) + "Presentation";
-	let contentBlock = "";
-	switch (presentationKind) {
-		case "web_component":
-			contentBlock = `  content: {
-    kind: 'web_component',
-    framework: 'react',
-    componentKey: '${name.replace(/\./g, "_")}',
-    props: new SchemaModel({
-      name: '${varName}Props',
-      description: 'Props for ${name}',
-      fields: {
-        // TODO: Define component props
-      },
-    }),
-    analytics: [
-      // TODO: Define analytics events
-    ],
-  },`;
-			break;
-		case "markdown":
-			contentBlock = `  content: {
-    kind: 'markdown',
-    content: \`
-# ${description}
-
-TODO: Add markdown content here
-    \`,
-    // Or use resourceUri: 'feature://${name}/guide.md'
-  },`;
-			break;
-		case "data":
-			contentBlock = `  content: {
-    kind: 'data',
-    mimeType: 'application/json',
-    model: new SchemaModel({
-      name: '${varName}Data',
-      description: 'Data structure for ${name}',
-      fields: {
-        // TODO: Define data structure
-      },
-    }),
-  },`;
-			break;
-	}
-	return `import type { PresentationSpec } from '@lssm/lib.contracts/presentations';
-import { SchemaModel, ScalarTypeEnum } from '@lssm/lib.schema';
-
-export const ${varName}: PresentationSpec = {
-  meta: {
-    name: '${name}',
-    version: ${version},
-    stability: '${stability}',
-    owners: [${owners.map((o) => `'${o}'`).join(", ")}],
-    tags: [${tags.map((t) => `'${t}'`).join(", ")}],
-    description: '${description}',
-  },
-  
-  policy: {
-    // flags: [],
-    // pii: [],
-  },
-  
-${contentBlock}
-};
-`;
-}
-
-//#endregion
-export { generatePresentationSpec };