@hookflo/tern 1.0.6 → 2.0.0

package/README.md

@@ -1,6 +1,11 @@
 # Tern - Algorithm Agnostic Webhook Verification Framework
 
 A robust, algorithm-agnostic webhook verification framework that supports multiple platforms with accurate signature verification and payload retrieval.
+The same framework that secures webhook verification at [Hookflo](https://hookflo.com).
+
+```bash
+npm install @hookflo/tern
+```
 
 [![npm version](https://img.shields.io/npm/v/@hookflo/tern)](https://www.npmjs.com/package/@hookflo/tern)
 [![TypeScript](https://img.shields.io/badge/TypeScript-Strict-blue)](https://www.typescriptlang.org/)
@@ -9,12 +14,13 @@ A robust, algorithm-agnostic webhook verification framework that supports multip
 Tern is a zero-dependency TypeScript framework for robust webhook verification across multiple platforms and algorithms.
 
 <img width="1396" height="470" style="border-radius: 10px" alt="tern bird nature" src="https://github.com/user-attachments/assets/5f0da3e6-1aba-4f88-a9d7-9d8698845c39" />
+
 ## Features
 
 - **Algorithm Agnostic**: Decouples platform logic from signature verification — verify based on cryptographic algorithm, not hardcoded platform rules.
 Supports HMAC-SHA256, HMAC-SHA1, HMAC-SHA512, and custom algorithms
 
-- **Platform Specific**: Accurate implementations for Stripe, GitHub, Clerk, and other platforms
+- **Platform Specific**: Accurate implementations for **Stripe, GitHub, Supabase, Clerk**, and other platforms
 - **Flexible Configuration**: Custom signature configurations for any webhook format
 - **Type Safe**: Full TypeScript support with comprehensive type definitions
 - **Framework Agnostic**: Works with Express.js, Next.js, Cloudflare Workers, and more
@@ -40,15 +46,18 @@ npm install @hookflo/tern
 ### Basic Usage
 
 ```typescript
-import { WebhookVerificationService } from '@hookflo/tern';
+import { WebhookVerificationService, platformManager } from '@hookflo/tern';
 
-// Verify a Stripe webhook
+// Method 1: Using the service (recommended)
 const result = await WebhookVerificationService.verifyWithPlatformConfig(
   request,
   'stripe',
   'whsec_your_stripe_webhook_secret'
 );
 
+// Method 2: Using platform manager (for platform-specific operations)
+const stripeResult = await platformManager.verify(request, 'stripe', 'whsec_your_secret');
+
 if (result.isValid) {
   console.log('Webhook verified!', result.payload);
 } else {
@@ -56,6 +65,21 @@ if (result.isValid) {
 }
 ```
 
+### Platform-Specific Usage
+
+```typescript
+import { platformManager } from '@hookflo/tern';
+
+// Run tests for a specific platform
+const testsPassed = await platformManager.runPlatformTests('stripe');
+
+// Get platform configuration
+const config = platformManager.getConfig('stripe');
+
+// Get platform documentation
+const docs = platformManager.getDocumentation('stripe');
+```
+
 ### Platform-Specific Configurations
 
 ```typescript
@@ -330,16 +354,33 @@ interface WebhookConfig {
 
 ## Testing
 
-Run the test suite:
+### Run All Tests
 
 ```bash
 npm test
 ```
 
-Run examples:
+### Platform-Specific Testing
 
 ```bash
-npm run examples
+# Test a specific platform
+npm run test:platform stripe
+
+# Test all platforms
+npm run test:all
+```
+
+### Documentation and Analysis
+
+```bash
+# Fetch platform documentation
+npm run docs:fetch
+
+# Generate diffs between versions
+npm run docs:diff
+
+# Analyze changes and generate reports
+npm run docs:analyze
 ```
 
 ## Examples
@@ -348,11 +389,30 @@ See the [examples.ts](./src/examples.ts) file for comprehensive usage examples.
 
 ## Contributing
 
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for detailed information on how to:
+
+- Set up your development environment
+- Add new platforms
+- Write tests
+- Submit pull requests
+- Follow our code style guidelines
+
+### Quick Start for Contributors
+
 1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Add tests for new functionality
-5. Submit a pull request
+2. Clone your fork: `git clone https://github.com/your-username/tern.git`
+3. Create a feature branch: `git checkout -b feature/your-feature-name`
+4. Make your changes
+5. Run tests: `npm test`
+6. Submit a pull request
+
+### Adding a New Platform
+
+See our [Platform Development Guide](CONTRIBUTING.md#adding-new-platforms) for step-by-step instructions on adding support for new webhook platforms.
+
+## Code of Conduct
+
+This project adheres to our [Code of Conduct](CODE_OF_CONDUCT.md). Please read it before contributing.
 
 ## 📄 License
 

package/dist/normalization/index.d.ts

@@ -0,0 +1,20 @@
+import { BaseTemplate, CreateSchemaInput, NormalizedResult, ProviderInfo, TemplateCategory, TransformParams, UpdateSchemaInput, UserSchema } from './types';
+import { StorageAdapter } from './storage/interface';
+export declare class Normalizer {
+    private readonly storage;
+    private engine;
+    constructor(storage?: StorageAdapter);
+    getBaseTemplates(): Promise<BaseTemplate[]>;
+    getProviders(category?: TemplateCategory): Promise<ProviderInfo[]>;
+    createSchema(input: CreateSchemaInput): Promise<UserSchema>;
+    updateSchema(schemaId: string, updates: UpdateSchemaInput): Promise<void>;
+    getSchema(id: string): Promise<UserSchema | null>;
+    transform(params: TransformParams): Promise<NormalizedResult>;
+    validateSchema(schema: UserSchema): Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+}
+export * from './types';
+export * from './storage/interface';
+export { InMemoryStorageAdapter } from './storage/memory';

package/dist/normalization/index.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryStorageAdapter = exports.Normalizer = void 0;
+const registry_1 = require("./providers/registry");
+const registry_2 = require("./templates/registry");
+const memory_1 = require("./storage/memory");
+const engine_1 = require("./transformer/engine");
+const validator_1 = require("./transformer/validator");
+class Normalizer {
+    constructor(storage = new memory_1.InMemoryStorageAdapter()) {
+        this.storage = storage;
+        this.engine = new engine_1.NormalizationEngine(storage, new validator_1.SchemaValidator());
+    }
+    async getBaseTemplates() {
+        return this.storage.listBaseTemplates();
+    }
+    async getProviders(category) {
+        return registry_1.providerRegistry.list(category);
+    }
+    async createSchema(input) {
+        const schema = {
+            id: generateId(),
+            userId: input.userId,
+            baseTemplateId: input.baseTemplateId,
+            category: input.category,
+            fields: input.fields,
+            providerMappings: input.providerMappings,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        await this.storage.saveSchema(schema);
+        return schema;
+    }
+    async updateSchema(schemaId, updates) {
+        await this.storage.updateSchema(schemaId, updates);
+    }
+    async getSchema(id) {
+        return this.storage.getSchema(id);
+    }
+    async transform(params) {
+        return this.engine.transform(params);
+    }
+    async validateSchema(schema) {
+        const base = (await this.storage.getBaseTemplate(schema.baseTemplateId))
+            ?? registry_2.templateRegistry.getById(schema.baseTemplateId);
+        if (!base) {
+            return {
+                valid: false,
+                errors: [`Base template not found: ${schema.baseTemplateId}`],
+            };
+        }
+        const validator = new validator_1.SchemaValidator();
+        return validator.validateSchema(schema, base);
+    }
+}
+exports.Normalizer = Normalizer;
+function generateId() {
+    // Simple non-crypto unique ID generator for framework default
+    return (`sch_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`);
+}
+__exportStar(require("./types"), exports);
+__exportStar(require("./storage/interface"), exports);
+var memory_2 = require("./storage/memory");
+Object.defineProperty(exports, "InMemoryStorageAdapter", { enumerable: true, get: function () { return memory_2.InMemoryStorageAdapter; } });

package/dist/normalization/providers/payment/paypal.d.ts

@@ -0,0 +1,2 @@
+import { ProviderMapping } from '../../types';
+export declare const paypalDefaultMapping: ProviderMapping;

package/dist/normalization/providers/payment/paypal.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paypalDefaultMapping = void 0;
+exports.paypalDefaultMapping = {
+    provider: 'paypal',
+    fieldMappings: [
+        { schemaFieldId: 'event_type', providerPath: 'event_type' },
+        { schemaFieldId: 'amount', providerPath: 'resource.amount.value', transform: 'toNumber' },
+        { schemaFieldId: 'currency', providerPath: 'resource.amount.currency_code', transform: 'toUpperCase' },
+        { schemaFieldId: 'transaction_id', providerPath: 'resource.id' },
+    ],
+};

package/dist/normalization/providers/payment/razorpay.d.ts

@@ -0,0 +1,2 @@
+import { ProviderMapping } from '../../types';
+export declare const razorpayDefaultMapping: ProviderMapping;

package/dist/normalization/providers/payment/razorpay.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.razorpayDefaultMapping = void 0;
+exports.razorpayDefaultMapping = {
+    provider: 'razorpay',
+    fieldMappings: [
+        { schemaFieldId: 'event_type', providerPath: 'event' },
+        { schemaFieldId: 'amount', providerPath: 'payload.payment.entity.amount' },
+        { schemaFieldId: 'currency', providerPath: 'payload.payment.entity.currency', transform: 'toUpperCase' },
+        { schemaFieldId: 'transaction_id', providerPath: 'payload.payment.entity.id' },
+        { schemaFieldId: 'customer_id', providerPath: 'payload.payment.entity.contact' },
+    ],
+};

package/dist/normalization/providers/payment/stripe.d.ts

@@ -0,0 +1,2 @@
+import { ProviderMapping } from '../../types';
+export declare const stripeDefaultMapping: ProviderMapping;

package/dist/normalization/providers/payment/stripe.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripeDefaultMapping = void 0;
+exports.stripeDefaultMapping = {
+    provider: 'stripe',
+    fieldMappings: [
+        { schemaFieldId: 'event_type', providerPath: 'type' },
+        { schemaFieldId: 'amount', providerPath: 'data.object.amount_received' },
+        { schemaFieldId: 'currency', providerPath: 'data.object.currency', transform: 'toUpperCase' },
+        { schemaFieldId: 'transaction_id', providerPath: 'data.object.id' },
+        { schemaFieldId: 'customer_id', providerPath: 'data.object.customer' },
+    ],
+};

package/dist/normalization/providers/registry.d.ts

@@ -0,0 +1,5 @@
+import { ProviderInfo } from '../types';
+export declare const providerRegistry: {
+    list(category?: ProviderInfo["category"]): ProviderInfo[];
+    getById(id: string): ProviderInfo | undefined;
+};

package/dist/normalization/providers/registry.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerRegistry = void 0;
+const providers = [
+    { id: 'stripe', name: 'Stripe', category: 'payment' },
+    { id: 'razorpay', name: 'Razorpay', category: 'payment' },
+    { id: 'paypal', name: 'PayPal', category: 'payment' },
+    { id: 'clerk', name: 'Clerk', category: 'auth' },
+    { id: 'auth0', name: 'Auth0', category: 'auth' },
+    { id: 'supabase', name: 'Supabase', category: 'auth' },
+    { id: 'shopify', name: 'Shopify', category: 'ecommerce' },
+    { id: 'woocommerce', name: 'WooCommerce', category: 'ecommerce' },
+];
+exports.providerRegistry = {
+    list(category) {
+        if (!category)
+            return providers;
+        return providers.filter((p) => p.category === category);
+    },
+    getById(id) {
+        return providers.find((p) => p.id === id);
+    },
+};

package/dist/normalization/storage/interface.d.ts

@@ -0,0 +1,13 @@
+import { BaseTemplate, UpdateSchemaInput, UserSchema } from '../types';
+export interface StorageAdapter {
+    saveSchema(schema: UserSchema): Promise<void>;
+    getSchema(id: string): Promise<UserSchema | null>;
+    updateSchema(id: string, updates: UpdateSchemaInput): Promise<void>;
+    deleteSchema(id: string): Promise<void>;
+    listSchemas(userId: string): Promise<UserSchema[]>;
+    getBaseTemplate(id: string): Promise<BaseTemplate | null>;
+    listBaseTemplates(): Promise<BaseTemplate[]>;
+}
+export interface NormalizationStorageOptions {
+    adapter: StorageAdapter;
+}

package/dist/normalization/storage/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/normalization/storage/memory.d.ts

@@ -0,0 +1,12 @@
+import { BaseTemplate, UpdateSchemaInput, UserSchema } from '../types';
+import { StorageAdapter } from './interface';
+export declare class InMemoryStorageAdapter implements StorageAdapter {
+    private schemas;
+    saveSchema(schema: UserSchema): Promise<void>;
+    getSchema(id: string): Promise<UserSchema | null>;
+    updateSchema(id: string, updates: UpdateSchemaInput): Promise<void>;
+    deleteSchema(id: string): Promise<void>;
+    listSchemas(userId: string): Promise<UserSchema[]>;
+    getBaseTemplate(id: string): Promise<BaseTemplate | null>;
+    listBaseTemplates(): Promise<BaseTemplate[]>;
+}

package/dist/normalization/storage/memory.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryStorageAdapter = void 0;
+const registry_1 = require("../templates/registry");
+class InMemoryStorageAdapter {
+    constructor() {
+        this.schemas = new Map();
+    }
+    async saveSchema(schema) {
+        this.schemas.set(schema.id, schema);
+    }
+    async getSchema(id) {
+        return this.schemas.get(id) ?? null;
+    }
+    async updateSchema(id, updates) {
+        const existing = this.schemas.get(id);
+        if (!existing)
+            return;
+        const updated = {
+            ...existing,
+            ...updates,
+            updatedAt: new Date(),
+        };
+        this.schemas.set(id, updated);
+    }
+    async deleteSchema(id) {
+        this.schemas.delete(id);
+    }
+    async listSchemas(userId) {
+        return Array.from(this.schemas.values()).filter((s) => s.userId === userId);
+    }
+    async getBaseTemplate(id) {
+        return registry_1.templateRegistry.getById(id) ?? null;
+    }
+    async listBaseTemplates() {
+        return registry_1.templateRegistry.listAll();
+    }
+}
+exports.InMemoryStorageAdapter = InMemoryStorageAdapter;

package/dist/normalization/templates/base/auth.d.ts

@@ -0,0 +1,2 @@
+import { BaseTemplate } from '../../types';
+export declare const authBaseTemplate: BaseTemplate;

package/dist/normalization/templates/base/auth.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authBaseTemplate = void 0;
+exports.authBaseTemplate = {
+    id: 'auth_v1',
+    category: 'auth',
+    version: '1.0.0',
+    fields: [
+        {
+            id: 'event_type', name: 'event_type', type: 'string', required: true,
+        },
+        {
+            id: 'user_id', name: 'user_id', type: 'string', required: true,
+        },
+        {
+            id: 'email', name: 'email', type: 'string', required: false,
+        },
+        {
+            id: 'status', name: 'status', type: 'string', required: true,
+        },
+    ],
+};

package/dist/normalization/templates/base/ecommerce.d.ts

@@ -0,0 +1,2 @@
+import { BaseTemplate } from '../../types';
+export declare const ecommerceBaseTemplate: BaseTemplate;

package/dist/normalization/templates/base/ecommerce.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ecommerceBaseTemplate = void 0;
+exports.ecommerceBaseTemplate = {
+    id: 'ecommerce_v1',
+    category: 'ecommerce',
+    version: '1.0.0',
+    fields: [
+        {
+            id: 'event_type', name: 'event_type', type: 'string', required: true,
+        },
+        {
+            id: 'order_id', name: 'order_id', type: 'string', required: true,
+        },
+        {
+            id: 'total', name: 'total', type: 'number', required: true,
+        },
+        {
+            id: 'currency', name: 'currency', type: 'string', required: true,
+        },
+        {
+            id: 'customer_id', name: 'customer_id', type: 'string', required: false,
+        },
+    ],
+};

package/dist/normalization/templates/base/payment.d.ts

@@ -0,0 +1,2 @@
+import { BaseTemplate } from '../../types';
+export declare const paymentBaseTemplate: BaseTemplate;

package/dist/normalization/templates/base/payment.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paymentBaseTemplate = void 0;
+exports.paymentBaseTemplate = {
+    id: 'payment_v1',
+    category: 'payment',
+    version: '1.0.0',
+    fields: [
+        {
+            id: 'event_type', name: 'event_type', type: 'string', required: true, description: 'Type of payment event',
+        },
+        {
+            id: 'amount', name: 'amount', type: 'number', required: true, description: 'Amount in the smallest currency unit',
+        },
+        {
+            id: 'currency', name: 'currency', type: 'string', required: true, description: 'Three-letter currency code',
+        },
+        {
+            id: 'transaction_id', name: 'transaction_id', type: 'string', required: true, description: 'Unique transaction identifier',
+        },
+        {
+            id: 'customer_id', name: 'customer_id', type: 'string', required: false, description: 'Customer identifier',
+        },
+    ],
+};

package/dist/normalization/templates/registry.d.ts

@@ -0,0 +1,6 @@
+import { BaseTemplate, TemplateCategory } from '../types';
+export declare const templateRegistry: {
+    getById(id: string): BaseTemplate | undefined;
+    listByCategory(category: TemplateCategory): BaseTemplate[];
+    listAll(): BaseTemplate[];
+};

package/dist/normalization/templates/registry.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateRegistry = void 0;
+const payment_1 = require("./base/payment");
+const auth_1 = require("./base/auth");
+const ecommerce_1 = require("./base/ecommerce");
+const templates = {
+    [payment_1.paymentBaseTemplate.id]: payment_1.paymentBaseTemplate,
+    [auth_1.authBaseTemplate.id]: auth_1.authBaseTemplate,
+    [ecommerce_1.ecommerceBaseTemplate.id]: ecommerce_1.ecommerceBaseTemplate,
+};
+exports.templateRegistry = {
+    getById(id) {
+        return templates[id];
+    },
+    listByCategory(category) {
+        return Object.values(templates).filter((t) => t.category === category);
+    },
+    listAll() {
+        return Object.values(templates);
+    },
+};

package/dist/normalization/transformer/engine.d.ts

@@ -0,0 +1,11 @@
+import { NormalizedResult, TransformParams } from '../types';
+import { StorageAdapter } from '../storage/interface';
+import { SchemaValidator } from './validator';
+export declare class NormalizationEngine {
+    private readonly storage;
+    private readonly validator;
+    constructor(storage: StorageAdapter, validator?: SchemaValidator);
+    transform(params: TransformParams): Promise<NormalizedResult>;
+    private extractValue;
+    private applyTransform;
+}

package/dist/normalization/transformer/engine.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NormalizationEngine = void 0;
+const registry_1 = require("../templates/registry");
+const validator_1 = require("./validator");
+class NormalizationEngine {
+    constructor(storage, validator = new validator_1.SchemaValidator()) {
+        this.storage = storage;
+        this.validator = validator;
+    }
+    async transform(params) {
+        const { rawPayload, provider, schemaId } = params;
+        const schema = await this.storage.getSchema(schemaId);
+        if (!schema)
+            throw new Error(`Schema not found: ${schemaId}`);
+        const baseTemplate = await this.storage.getBaseTemplate(schema.baseTemplateId) || registry_1.templateRegistry.getById(schema.baseTemplateId);
+        if (!baseTemplate)
+            throw new Error(`Base template not found: ${schema.baseTemplateId}`);
+        const validation = this.validator.validateSchema(schema, baseTemplate);
+        if (!validation.valid) {
+            throw new Error(`Invalid schema: ${validation.errors.join('; ')}`);
+        }
+        const providerMapping = schema.providerMappings.find((m) => m.provider === provider);
+        if (!providerMapping)
+            throw new Error(`No mapping found for provider: ${provider}`);
+        const normalized = {};
+        for (const field of schema.fields) {
+            if (!field.enabled)
+                continue;
+            const mapping = providerMapping.fieldMappings.find((m) => m.schemaFieldId === field.id);
+            if (mapping) {
+                const value = this.extractValue(rawPayload, mapping.providerPath);
+                const finalValue = this.applyTransform(value, mapping.transform);
+                normalized[field.name] = finalValue ?? field.defaultValue;
+            }
+            else if (field.required) {
+                if (field.defaultValue !== undefined) {
+                    normalized[field.name] = field.defaultValue;
+                }
+                else {
+                    throw new Error(`Required field ${field.name} has no mapping`);
+                }
+            }
+        }
+        const outValidation = this.validator.validateOutput(normalized, schema, baseTemplate);
+        if (!outValidation.valid) {
+            throw new Error(`Normalized output invalid: ${outValidation.errors.join('; ')}`);
+        }
+        return {
+            normalized,
+            meta: {
+                provider,
+                schemaId,
+                schemaVersion: schema.baseTemplateId,
+                transformedAt: new Date(),
+            },
+        };
+    }
+    extractValue(obj, path) {
+        if (!path)
+            return undefined;
+        return path.split('.').reduce((acc, key) => (acc == null ? undefined : acc[key]), obj);
+    }
+    applyTransform(value, transform) {
+        if (transform == null)
+            return value;
+        if (value == null)
+            return value;
+        if (transform === 'toUpperCase')
+            return String(value).toUpperCase();
+        if (transform === 'toLowerCase')
+            return String(value).toLowerCase();
+        if (transform === 'toNumber')
+            return typeof value === 'number' ? value : Number(value);
+        if (transform.startsWith('divide:')) {
+            const denominator = Number(transform.split(':')[1]);
+            return Number(value) / denominator;
+        }
+        if (transform.startsWith('multiply:')) {
+            const factor = Number(transform.split(':')[1]);
+            return Number(value) * factor;
+        }
+        return value;
+    }
+}
+exports.NormalizationEngine = NormalizationEngine;

package/dist/normalization/transformer/validator.d.ts

@@ -0,0 +1,12 @@
+import { BaseTemplate, UserSchema } from '../types';
+export declare class SchemaValidator {
+    validateSchema(userSchema: UserSchema, baseTemplate: BaseTemplate): {
+        valid: boolean;
+        errors: string[];
+    };
+    validateOutput(output: Record<string, unknown>, userSchema: UserSchema, baseTemplate: BaseTemplate): {
+        valid: boolean;
+        errors: string[];
+    };
+    private matchesType;
+}