@modality-counter/core 0.0.0

package/dist/types/__tests__/CategoryLinkValidation.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Category Link Validation Test Suite
+ *
+ * Validates that method files in category folders exist and are symbolic links
+ *
+ * New path structure:
+ * - Skills: methods/native/skills/[method]/SKILL.mdx
+ * - Category links: methods/native/categories/[category]/[method] -> ../../skills/[method]
+ */
+/**
+ * Setup category link validation tests - can be imported and reused in other projects
+ */
+export declare function setupCategoryLinkValidation(): Promise<void>;

package/dist/types/__tests__/MethodValidation.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * General Method Validation Test Suite
+ *
+ * Validates ALL method files against the Zod schema.
+ * Uses getAllCounterItems for discovery, getCounterContent for data.
+ */
+/**
+ * Setup method validation tests - can be imported and reused in other projects
+ */
+export declare function setupMethodValidation(): Promise<void>;

package/dist/types/__tests__/PersonaValidation.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * General Persona Validation Test Suite
+ *
+ * Validates ALL persona files against the Zod schema.
+ * Auto-discovers .mdx files in personas directory.
+ */
+/**
+ * Setup persona validation tests - can be imported and reused in other projects
+ */
+export declare function setupPersonaValidation(): void;

package/dist/types/__tests__/TemplateValidator.test.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Zod-Based Template Validator with Enhanced YAML Validation
+ *
+ * This test suite uses TypeScript-first Zod schemas for template validation,
+ * ensuring type-safe validation with superior error messages.
+ * Performance optimized with caching to prevent repeated file I/O.
+ *
+ * Features:
+ * - Type-safe validation with automatic TypeScript types
+ * - Runtime validation with detailed error paths
+ * - Comprehensive template structure validation
+ * - Quality metrics validation with precise scoring
+ * - EXPLICIT YAML format validation - any invalid YAML will cause test failure
+ * - Enhanced error handling for both YAML syntax and template structure errors
+ */
+/**
+ * Setup template validation tests - can be imported and reused in other projects
+ */
+export declare function setupTemplateValidation(): void;

package/dist/types/__tests__/security-integrity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/__tests__/security-validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/confs/const.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_CHAR_LENGTH = 23000;
+export declare const DEPLOY_METHOD_TOOL = "_Counter__ExecuteMethod";

package/dist/types/confs/domain-config.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Domain Configuration for Fetch-Page Elicit
+ *
+ * Centralized configuration for domain-specific behavior.
+ * Use this to specify domains that require special handling (e.g., Google Bot user agent).
+ */
+/**
+ * Domains that should use Google Bot user agent
+ * These sites serve more content to Google Bot crawler than regular browsers
+ *
+ * Common reasons to use Google Bot:
+ * - E-commerce sites (Shopee, Lazada, etc.) show more products/details to crawlers
+ * - SEO-optimized sites serve complete content to search engine crawlers
+ * - Some sites block fake User-Agents but allow Googlebot
+ */
+export declare const GOOGLEBOT_DOMAINS: Set<string>;
+/**
+ * Check if a URL's domain should use Google Bot user agent
+ *
+ * @param url - Full URL to check (e.g., "https://www.shopee.tw/...")
+ * @returns true if the domain should use Google Bot user agent
+ *
+ * @example
+ * isGoogleBotDomain("https://www.shopee.tw/search") // true
+ * isGoogleBotDomain("https://google.com") // false
+ */
+export declare function isGoogleBotDomain(url: string): boolean;

package/dist/types/counter_aliases.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Centralized Aliases Configuration
+ *
+ * This file contains all aliases for:
+ * - Method aliases extracted from YAML files and persona descriptions
+ * - Hero aliases for convenient deployment shortcuts
+ *
+ * Provides bidirectional mapping for alias resolution.
+ */
+declare const METHOD_TO_ALIASES: {
+    readonly code: readonly ["change", "modify", "develop", "update", "implement", "add", "remove", "fix", "improve"];
+    readonly "code-verify": readonly ["check", "code-test"];
+    readonly "fix-bun-test": readonly ["bun-test"];
+    readonly "counter-manager": readonly ["method-manager"];
+    readonly presentation: readonly ["ppt"];
+    readonly "daily-planner": readonly ["daily"];
+    readonly help: readonly ["assemble"];
+    readonly "business-edm": readonly ["b2b"];
+    readonly "transform-narrative": readonly ["write"];
+    readonly "persuade-convert": readonly ["sell"];
+    readonly "technical-engage": readonly ["blog"];
+    readonly "task-decomposer": readonly ["atomic"];
+    readonly "content-intelligence": readonly ["content", "audit", "audience"];
+    readonly "visual-craft": readonly ["image"];
+    readonly "get-cursor-codesymbol": readonly ["cursor"];
+    readonly "fomo-retail-investor": readonly ["fomo"];
+    readonly "crisis-response": readonly ["sos"];
+};
+declare const ALIAS_TO_METHOD: Record<string, AliasConfig>;
+export type MethodName = keyof typeof METHOD_TO_ALIASES;
+export type AliasName = keyof typeof ALIAS_TO_METHOD;
+export type AliasConfig = {
+    method: string;
+    parameters?: Record<string, any>;
+};
+export declare const getAliasesForMethod: (method: MethodName) => readonly string[];
+export declare const getMethodForAlias: (alias: string) => AliasConfig | undefined;
+export declare const isValidAlias: (alias: string) => alias is AliasName;
+export declare const getAllMethods: () => readonly MethodName[];
+export declare const getAllAliases: () => readonly AliasName[];
+/**
+ * Hero alias mapping for convenient deployment
+ * Maps common shortcuts to actual hero IDs
+ */
+export declare const HERO_ALIASES: Record<string, string>;
+/**
+ * Resolve hero alias to actual hero ID or name
+ */
+export declare function resolveHeroAlias(heroCallSign: string): string;
+/**
+ * Get all available hero names dynamically from persona files
+ * Uses getAllCounterItems to fetch real hero data programmatically
+ */
+export declare function getAllHeroNames(): Promise<string[]>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,25 @@
+export { default as AnswerProtocol } from "./protocols/answer-protocol.mdx";
+export { default as BehaviorProtocol } from "./protocols/behavior-protocol.mdx";
+export { default as CleanCodeProtocol } from "./protocols/clean-code-protocol.mdx";
+export { default as CodesymbolProtocol } from "./protocols/codesymbol-protocol.mdx";
+export { default as CulturalLinguisticProtocol } from "./protocols/cultural-linguistic-protocol.mdx";
+export { default as FloamProtocol } from "./protocols/floam-protocol.mdx";
+export { default as PartyModeProtocol } from "./protocols/party-mode-protocol.mdx";
+export { default as TaiwanEcommerceProtocol } from "./protocols/taiwan-ecommerce-protocol.mdx";
+export { default as TwoStageProtocol } from "./protocols/two-stage-protocol.mdx";
+export { DeepWiki } from "./util_scripts/DeepWiki";
+export { MAX_CHAR_LENGTH } from "./confs/const";
+export { isGoogleBotDomain } from "./confs/domain-config";
+export { getPagination, needsChunking, getChunk, } from "./util_scripts/pagination";
+export { DEPLOY_METHOD_TOOL } from "./confs/const.js";
+export { getCounterContent, getAllCounterItems } from "./util_counter_data";
+export { setupMcpCounter } from "./mcp_counter";
+export { setupTemplateValidation } from "./__tests__/TemplateValidator.test.js";
+export { setupCategoryLinkValidation } from "./__tests__/CategoryLinkValidation.test.js";
+export { setupMethodValidation } from "./__tests__/MethodValidation.test.js";
+export { setupPersonaValidation } from "./__tests__/PersonaValidation.test.js";
+export { validateMethodFile } from "./schemas/methodology-validation.js";
+export { validateTemplateFile } from "./schemas/template-validation.js";
+export { validateProtocolFile } from "./schemas/protocol-validation.js";
+export { extractCodeBlocks, readMpxPrompt, readMpxYaml, readPrompt } from "./util_prompts";
+export { readMdx, importMdx } from "./util_mdx";

package/dist/types/mcp_counter.d.ts

@@ -0,0 +1,5 @@
+import { type AITools, type FastMCPCompatible } from "modality-mcp-kit";
+/**
+ * Setup MCP tools
+ */
+export declare const setupMcpCounter: (baseDir: string, mcpServer?: FastMCPCompatible) => Promise<AITools>;

package/dist/types/protocols/__tests__/BehaviorProtocol.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/protocols/__tests__/PartyModeProtocol.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/protocols/__tests__/ProtocolValidation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/schemas/ExecutionFlow.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const ExecutionFlowItemSchema: z.ZodType<string | any[] | {
+    [key: string]: any[];
+}>;
+export declare const ExecutionFlowSchema: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+    [key: string]: any[];
+}, unknown, z.core.$ZodTypeInternals<string | any[] | {
+    [key: string]: any[];
+}, unknown>>>>;
+export type ExecutionFlowItem = z.infer<typeof ExecutionFlowItemSchema>;
+export type ExecutionFlow = z.infer<typeof ExecutionFlowSchema>;

package/dist/types/schemas/counter_schemas.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+export declare const ResourceTypes: readonly ["persona", "method", "workflow"];
+export type ResourceType = (typeof ResourceTypes)[number];
+export declare const partyModeSchema: z.ZodObject<{
+    topic: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    recommendedHeroes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deployedHeroes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PartyMode = z.infer<typeof partyModeSchema>;
+export declare const heroMethodSchema: z.ZodObject<{
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+export type HeroMethodType = z.infer<typeof heroMethodSchema>;
+export declare const heroDeploySchema: z.ZodObject<{
+    callSign: z.ZodString;
+}, z.core.$strip>;
+export type HeroDeployType = z.infer<typeof heroDeploySchema>;
+export declare const workflowDeploySchema: z.ZodObject<{
+    callSign: z.ZodString;
+}, z.core.$strip>;
+export type WorkflowDeployType = z.infer<typeof workflowDeploySchema>;
+export declare const counterAssembleSchema: z.ZodObject<{
+    types: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        persona: "persona";
+        method: "method";
+        workflow: "workflow";
+    }>>>;
+}, z.core.$strip>;
+export type CounterAssembleType = z.infer<typeof counterAssembleSchema>;

package/dist/types/schemas/methodology-validation.d.ts

@@ -0,0 +1,180 @@
+import { z } from "zod";
+declare const ExpectedOutputSchema: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>]>;
+declare const ParameterDefinitionSchema: z.ZodObject<{
+    description: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        array: "array";
+        integer: "integer";
+    }>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+}, z.core.$catchall<z.ZodUnknown>>;
+declare const UsageSchema: z.ZodObject<{
+    method: z.ZodString;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+            integer: "integer";
+        }>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$catchall<z.ZodUnknown>>>>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    elicit: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+declare const TemplateIntegrationSchema: z.ZodArray<z.ZodObject<{
+    template_ref: z.ZodString;
+    description: z.ZodString;
+    when_to_trigger: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>>;
+declare const CompositionSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    method: z.ZodString;
+    purpose: z.ZodString;
+    execution_flow: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+        [key: string]: any[];
+    }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+        [key: string]: any[];
+    }, unknown>>>>;
+    when_to_trigger: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+        [key: string]: any[];
+    }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+        [key: string]: any[];
+    }, unknown>>>>;
+}, z.core.$strict>>>;
+declare const ActionChecklistSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>>;
+declare const UsageModeConfigSchema: z.ZodObject<{
+    purpose: z.ZodString;
+    execution_flow: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+        [key: string]: any[];
+    }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+        [key: string]: any[];
+    }, unknown>>>>;
+    fallback: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    when_to_trigger: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+        [key: string]: any[];
+    }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+        [key: string]: any[];
+    }, unknown>>>>;
+    usage_example: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const TacticalNotesSchema: z.ZodAny;
+declare const MethodologySchema: z.ZodObject<{
+    purpose: z.ZodString;
+    expected_output: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>]>;
+    composition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        method: z.ZodString;
+        purpose: z.ZodString;
+        execution_flow: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+            [key: string]: any[];
+        }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+            [key: string]: any[];
+        }, unknown>>>>;
+        when_to_trigger: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+            [key: string]: any[];
+        }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+            [key: string]: any[];
+        }, unknown>>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const MethodFileSchema: z.ZodObject<{
+    method: z.ZodObject<{
+        name: z.ZodString;
+        title: z.ZodString;
+        icon: z.ZodString;
+        category: z.ZodString;
+        description: z.ZodString;
+        usage: z.ZodObject<{
+            method: z.ZodString;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                description: z.ZodString;
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    array: "array";
+                    integer: "integer";
+                }>;
+                required: z.ZodDefault<z.ZodBoolean>;
+                options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+            }, z.core.$catchall<z.ZodUnknown>>>>;
+            examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            elicit: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        agent_compatibility: z.ZodArray<z.ZodString>;
+        references: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodString;
+            content: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strict>;
+    methodology: z.ZodObject<{
+        purpose: z.ZodString;
+        expected_output: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>]>;
+        composition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            method: z.ZodString;
+            purpose: z.ZodString;
+            execution_flow: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+                [key: string]: any[];
+            }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+                [key: string]: any[];
+            }, unknown>>>>;
+            when_to_trigger: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+                [key: string]: any[];
+            }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+                [key: string]: any[];
+            }, unknown>>>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    template_integration: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        template_ref: z.ZodString;
+        description: z.ZodString;
+        when_to_trigger: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    integration_protocols: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    usage_modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        purpose: z.ZodString;
+        execution_flow: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+            [key: string]: any[];
+        }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+            [key: string]: any[];
+        }, unknown>>>>;
+        fallback: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        when_to_trigger: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+            [key: string]: any[];
+        }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+            [key: string]: any[];
+        }, unknown>>>>;
+        usage_example: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    multi_market_integration: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    data_sources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    tactical_notes: z.ZodAny;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type MethodFile = z.infer<typeof MethodFileSchema>;
+export type ExpectedOutput = z.infer<typeof ExpectedOutputSchema>;
+export type Methodology = z.infer<typeof MethodologySchema>;
+export type Composition = z.infer<typeof CompositionSchema>;
+export type TemplateIntegration = z.infer<typeof TemplateIntegrationSchema>;
+export type ParameterDefinition = z.infer<typeof ParameterDefinitionSchema>;
+export type Usage = z.infer<typeof UsageSchema>;
+export type UsageModeConfig = z.infer<typeof UsageModeConfigSchema>;
+export type ActionChecklist = z.infer<typeof ActionChecklistSchema>;
+export type TacticalNotes = z.infer<typeof TacticalNotesSchema>;
+export declare function validateMethodFile(data: unknown, filename?: string): {
+    success: boolean;
+    data?: MethodFile;
+    errors?: string[];
+};
+export {};

package/dist/types/schemas/persona-validation.d.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import type { PersonaValidationResult } from "./validation-types.js";
+/**
+ * Zod Schema for Counter Persona Validation
+ * TypeScript-first validation for Counter persona definition files
+ *
+ * Features:
+ * - Type-safe validation with automatic TypeScript type generation
+ * - Runtime validation with detailed error messages for persona configurations
+ * - Support for agent identity, persona traits, and method definitions
+ * - Comprehensive validation rules for persona consistency and quality
+ */
+declare const AgentSectionSchema: z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodString;
+    title: z.ZodString;
+    icon: z.ZodString;
+    whenToUse: z.ZodArray<z.ZodString>;
+    description: z.ZodString;
+}, z.core.$strip>;
+declare const PersonaSectionSchema: z.ZodObject<{
+    role: z.ZodString;
+    style: z.ZodString;
+    identity: z.ZodString;
+    focus: z.ZodString;
+    core_principles: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+        [key: string]: any[];
+    }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+        [key: string]: any[];
+    }, unknown>>>>;
+}, z.core.$strict>;
+export declare const PersonaFileSchema: z.ZodObject<{
+    agent: z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodString;
+        title: z.ZodString;
+        icon: z.ZodString;
+        whenToUse: z.ZodArray<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strip>;
+    persona: z.ZodObject<{
+        role: z.ZodString;
+        style: z.ZodString;
+        identity: z.ZodString;
+        focus: z.ZodString;
+        core_principles: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+            [key: string]: any[];
+        }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+            [key: string]: any[];
+        }, unknown>>>>;
+    }, z.core.$strict>;
+    methods: z.ZodRecord<z.ZodString, z.ZodString>;
+    dependencies: z.ZodObject<{
+        methods: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type PersonaFile = z.infer<typeof PersonaFileSchema>;
+export type AgentSection = z.infer<typeof AgentSectionSchema>;
+export type PersonaSection = z.infer<typeof PersonaSectionSchema>;
+export declare function validatePersonaFile(data: unknown): {
+    success: boolean;
+    data?: PersonaFile;
+    errors?: string[];
+};
+export declare function calculatePersonaQualityScore(result: Pick<PersonaValidationResult, "errors" | "warnings" | "advisories">): number;
+export declare function validatePersonaWithQuality(data: unknown, filename: string): PersonaValidationResult;
+export declare function extractPersonaYamlFromMdx(mdxContent: string): unknown;
+export {};

package/dist/types/schemas/protocol-validation.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const GenericProtocolSchema: z.ZodObject<{}, z.core.$catchall<z.ZodRecord<z.ZodString, z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>>>;
+export type GenericProtocol = z.infer<typeof GenericProtocolSchema>;
+export declare function validateGenericProtocol(data: unknown): {
+    success: boolean;
+    data?: GenericProtocol;
+    errors?: string[];
+};
+export interface ProtocolValidationResult {
+    filename: string;
+    type: "protocol";
+    status: "excellent" | "good_with_warnings" | "critical_error";
+    errors: string[];
+    warnings: string[];
+    advisories: string[];
+    score: number;
+}
+export declare function calculateProtocolQualityScore(result: Pick<ProtocolValidationResult, "errors" | "warnings" | "advisories">): number;
+export declare function validateProtocolFile(data: unknown): ProtocolValidationResult;

package/dist/types/schemas/template-validation.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+/**
+ * Zod Schema for Counter Template Validation
+ * Independent TypeScript-first validation for template files
+ *
+ * Features:
+ * - Type-safe template validation with automatic TypeScript types
+ * - Runtime validation with detailed error messages
+ * - Template-specific validation rules and requirements
+ * - Quality scoring and compliance assessment
+ */
+declare const OutputStructureSchema: z.ZodObject<{
+    header_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    separators: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    body_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    footer_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+declare const DisplayFormatSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
+declare const TemplateOutputSchema: z.ZodObject<{
+    format: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    structure: z.ZodOptional<z.ZodObject<{
+        header_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        separators: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        body_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        footer_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+declare const TemplateSectionSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    sub_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    content: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    focus: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>;
+declare const TemplateSectionsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    sub_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    content: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    focus: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>>;
+export declare const TemplateFileSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    template: z.ZodObject<{
+        output: z.ZodOptional<z.ZodObject<{
+            format: z.ZodOptional<z.ZodString>;
+            filename: z.ZodOptional<z.ZodString>;
+            structure: z.ZodOptional<z.ZodObject<{
+                header_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                separators: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                body_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                footer_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+        }, z.core.$strip>>;
+        display_format: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strict>;
+    execution_flow: z.ZodOptional<z.ZodArray<z.ZodType<string | any[] | {
+        [key: string]: any[];
+    }, unknown, z.core.$ZodTypeInternals<string | any[] | {
+        [key: string]: any[];
+    }, unknown>>>>;
+    sections: z.ZodRecord<z.ZodString, z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        sub_sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        content: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        focus: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodUnknown>>>;
+}, z.core.$strict>>;
+export type TemplateFile = z.infer<typeof TemplateFileSchema>;
+export type TemplateOutput = z.infer<typeof TemplateOutputSchema>;
+export type OutputStructure = z.infer<typeof OutputStructureSchema>;
+export type DisplayFormat = z.infer<typeof DisplayFormatSchema>;
+export type TemplateSections = z.infer<typeof TemplateSectionsSchema>;
+export type TemplateSection = z.infer<typeof TemplateSectionSchema>;
+export declare function validateTemplateFile(data: unknown): {
+    success: boolean;
+    data?: TemplateFile;
+    errors?: string[];
+};
+export {};