okai 0.0.22 → 0.0.24

package/dist/api.d.ts

@@ -0,0 +1,352 @@
+declare global {
+    export class AuditBase {
+        createdDate: Date
+        createdBy: string
+        modifiedDate: Date
+        modifiedBy: string
+        deletedDate?: Date
+        deletedBy?: string
+    }
+
+    export type TypeOf = `typeof(${string})`
+    export type InputAttrOptions = { type?:string, value?:string, placeholder?:string, help?:string, label?:string, title?:string, size?:string, 
+        pattern?:string, readOnly?:boolean, required?:boolean, disabled?:boolean, autocomplete?:string, autofocus?:string, 
+        min?:string, max?:string, step?:string, minLength?:number, maxLength?:number, accept?:string, capture?:string, multiple?:boolean, 
+        allowableValues?:string[], allowableValuesEnum?:TypeOf, options?:string, ignore?:boolean, evalAllowableValues?:string, evalAllowableEntries?:string, }
+    export type ScriptValueOptions = { value?: any,  expression?: string, eval?: string,  noCache?: boolean }
+
+    type ClassDecoratorDef = (
+        target: any,
+        context: ClassDecoratorContext
+    ) => void
+
+    type ClassFieldDecoratorDef = (
+        target: any,
+        context: ClassFieldDecoratorContext
+    ) => void
+
+    type ClassOrFieldDecoratorDef = (
+        target: any,
+        context: ClassDecoratorContext | ClassFieldDecoratorContext
+    ) => void
+
+    export function validateRequest(validator:string) : ClassDecoratorDef
+    export function validateIsAuthenticated() : ClassDecoratorDef
+    export function validateIsAdmin() : ClassDecoratorDef
+    export function validateAuthSecret() : ClassDecoratorDef
+    export function validateHasRole(role:string) : ClassDecoratorDef
+    export function validateHasRoles(roles:string[]) : ClassDecoratorDef
+    export function validateHasPermission(permission:string) : ClassDecoratorDef
+    export function validateHasPermissions(permissions:string[]) : ClassDecoratorDef
+    export function validateHasClaim(claim:string) : ClassDecoratorDef
+    export function validateHasScope(scope:string) : ClassDecoratorDef
+    export function validateApiKey(scope?:string) : ClassDecoratorDef
+    
+    export function schema(schema:string) : ClassDecoratorDef
+    export function compositeKey(columns:string[]) : ClassDecoratorDef
+    export function compositeIndex(unique:boolean, columns:string[]) : ClassDecoratorDef
+    export function preCreateTable(sql:string) : ClassDecoratorDef
+    export function preDropTable(sql:string) : ClassDecoratorDef
+    export function postCreateTable(sql:string) : ClassDecoratorDef
+    export function postDropTable(sql:string) : ClassDecoratorDef
+    
+    export function api(description:string, opt?:{ bodyParameter?:number, requestContentType?:string, isRequired?:boolean }) : ClassDecoratorDef
+    export function apiResponse(statusCode:number, description:string, opt?:{ isDefaultResponse?:boolean, responseType?:TypeOf }) : ClassDecoratorDef
+    
+    export function dataContract() : ClassDecoratorDef
+    export function route(path:string, opt?:{ summary?:string, notes?:string, verbs?:string, priority?:number, matches?:string, }) : ClassDecoratorDef
+    export function icon(opt?:{ svg?:string, uri?:string, alt?:string, cls?:string, }) : ClassDecoratorDef
+    export function field(opt?:InputAttrOptions & { name?:string, fieldCss?:string, inputCss?:string, labelCss?:string, }) : ClassDecoratorDef
+    export function tag(name:string) : ClassDecoratorDef
+    export function worker(name:string) : ClassDecoratorDef
+    export function notes(notes:string) : ClassDecoratorDef
+    export function namedConnection(name:string) : ClassDecoratorDef
+    
+    export enum QueryTerm { Default = 0, And = 1, Or = 2, Ensure = 3, }
+    export function queryDb(defaultTerm:QueryTerm) : ClassDecoratorDef
+    export function queryData(defaultTerm:QueryTerm) : ClassDecoratorDef
+    export function autoFilter(term:QueryTerm, field?:string, opt?:{ operand?:string, template?:string, valueFormat:string }) : ClassDecoratorDef
+    export function autoPopulate(field?:string, opt?:ScriptValueOptions) : ClassDecoratorDef
+    export class SqlTemplate {
+        static IsNull: string
+        static IsNotNull: string
+        static GreaterThanOrEqual: string
+        static GreaterThan: string
+        static LessThan: string
+        static LessThanOrEqual: string
+        static NotEqual: string
+        static CaseSensitiveLike: string
+        static CaseInsensitiveLike: string
+    }
+
+    export function alias(table:string) : ClassOrFieldDecoratorDef
+    export function meta(name:string,value:string) : ClassOrFieldDecoratorDef
+    export function priority(value:string) : ClassOrFieldDecoratorDef
+    
+    // Enum decorators
+    export function flags() : ClassDecoratorDef
+    export function enumMember(opt:{ value:string }) : ClassFieldDecoratorDef
+    
+    export function validate(validator:string) : ClassFieldDecoratorDef
+    export function validateNull() : ClassFieldDecoratorDef
+    export function validateEmpty() : ClassFieldDecoratorDef
+    export function validateEmail() : ClassFieldDecoratorDef
+    export function validateNotNull() : ClassFieldDecoratorDef
+    export function validateNotEmpty() : ClassFieldDecoratorDef
+    export function validateCreditCard() : ClassFieldDecoratorDef
+    export function validateLength(min:number, max:number) : ClassFieldDecoratorDef
+    export function validateExactLength(length:number) : ClassFieldDecoratorDef
+    export function validateMinimumLength(min:number) : ClassFieldDecoratorDef
+    export function validateMaximumLength(max:number) : ClassFieldDecoratorDef
+    export function validateLessThan(value:number) : ClassFieldDecoratorDef
+    export function validateLessThanOrEqual(value:number) : ClassFieldDecoratorDef
+    export function validateGreaterThan(value:number) : ClassFieldDecoratorDef
+    export function validateGreaterThanOrEqual(value:number) : ClassFieldDecoratorDef
+    export function validateScalePrecision(scale:number, precision:number) : ClassFieldDecoratorDef
+    export function validateRegularExpression(pattern:string) : ClassFieldDecoratorDef
+    export function validateEqualExpression(value:string|number|boolean) : ClassFieldDecoratorDef
+    export function validateNotEqualExpression(value:string|number|boolean) : ClassFieldDecoratorDef
+    export function validateInclusiveBetween(from:string|number,to:string|number) : ClassFieldDecoratorDef
+    export function validateExclusiveBetween(from:string|number,to:string|number) : ClassFieldDecoratorDef
+    
+    export function allowReset() : ClassFieldDecoratorDef
+    export function denyReset() : ClassFieldDecoratorDef
+    
+    export function primaryKey() : ClassFieldDecoratorDef
+    export function autoId() : ClassFieldDecoratorDef
+    export function autoIncrement() : ClassFieldDecoratorDef
+    export function belongTo(BelongToTableType:TypeOf) : ClassFieldDecoratorDef
+    export function index(opt?:{ name?:string, unique?:boolean, clustered?:boolean, nonClustered?:boolean, }) : ClassFieldDecoratorDef
+    export function compute() : ClassFieldDecoratorDef
+    export function computed() : ClassFieldDecoratorDef
+    export function persisted() : ClassFieldDecoratorDef
+    export function uniqueConstraint(columns:string[]) : ClassFieldDecoratorDef
+    export function addColumn() : ClassFieldDecoratorDef
+    export function removeColumn() : ClassFieldDecoratorDef
+    export function checkConstraint(constraint:string) : ClassFieldDecoratorDef
+    export function customField(sql:string, order?:number) : ClassFieldDecoratorDef
+    export function customSelect(sql:string) : ClassFieldDecoratorDef
+    export function customInsert(sql:string) : ClassFieldDecoratorDef
+    export function customUpdate(sql:string) : ClassFieldDecoratorDef
+    export function decimalLength(precision:number, scale?:number) : ClassFieldDecoratorDef
+    export function Default(value:string|number|boolean) : ClassFieldDecoratorDef
+    export function description(description:string) : ClassFieldDecoratorDef
+    export function enumAsInt() : ClassFieldDecoratorDef
+    export function excludeMetadata() : ClassFieldDecoratorDef
+    export function excludeFromDescription() : ClassFieldDecoratorDef
+    export function explicitAutoQuery() : ClassFieldDecoratorDef
+    export type foreignKeyBehavior = "NO ACTION"|"RESTRICT"|"SET NULL"|"SET DEFAULT"|"CASCADE"
+    export function foreignKey(type:string, opt?:{ onDelete?:foreignKeyBehavior, onUpdate?:foreignKeyBehavior, foreignKeyName?:string }) : ClassFieldDecoratorDef
+    export function ignore() : ClassFieldDecoratorDef
+    export function ignoreOnUpdate() : ClassFieldDecoratorDef
+    export function ignoreOnInsert() : ClassFieldDecoratorDef
+    export function ignoreDataMember() : ClassFieldDecoratorDef
+    export function reference() : ClassFieldDecoratorDef
+    export function referenceField(model:TypeOf, id?:string, field?:string) : ClassFieldDecoratorDef
+    export function references(type:TypeOf) : ClassFieldDecoratorDef
+    export function required() : ClassFieldDecoratorDef
+    export function returnOnInsert() : ClassFieldDecoratorDef
+    export function rowVersion() : ClassFieldDecoratorDef
+    export function unique() : ClassFieldDecoratorDef
+    
+    export enum ValueStyle { Single, Multiple, List, }
+    export function queryDbField(opt?:{ term:QueryTerm, operand?:string, template?:string, field?:string, valueFormat?:string, valueStyle?:ValueStyle, valueArity?:number }) : ClassFieldDecoratorDef
+    export function queryDataField(opt?:{ term:QueryTerm, condition?:string, field?:string }) : ClassFieldDecoratorDef
+    
+    export enum AutoUpdateStyle { Always, NonDefaults }
+    export function autoUpdate(style:AutoUpdateStyle) : ClassFieldDecoratorDef
+    export function autoDefault(opt:ScriptValueOptions) : ClassFieldDecoratorDef
+    export function autoMap(to:string) : ClassFieldDecoratorDef
+    export function autoIgnore() : ClassFieldDecoratorDef
+    export function autoApply(name:string, args?:string[]) : ClassFieldDecoratorDef
+    
+    export function apiMember(opt?:{ name?:string, verb?:string, parameterType?:string, description?:string, dataType?:string,
+        format?:string, isRequired?:boolean, isOptional?:boolean, allowMultiple?:boolean, route?:string, excludeInSchema?:boolean
+    }) : ClassFieldDecoratorDef
+    export function apiAllowableValues(name:string, opt?:{ type?:"RANGE"|"LIST", min?:number, max?:number, values?:string[] }) : ClassFieldDecoratorDef
+    
+    export function dataMember(opt?:{ name?:string, order?:number, isRequired?:boolean }) : ClassFieldDecoratorDef
+    export function input(opt?:InputAttrOptions) : ClassFieldDecoratorDef
+    export function fieldCss(opt?:{ field?:string, input?:string, label?:string, }) : ClassFieldDecoratorDef
+    export function explorerCss(opt?:{ form?:string, fieldset?:string, field?:string, }) : ClassFieldDecoratorDef
+    export function locodeCss(opt?:{ form?:string, fieldset?:string, field?:string, }) : ClassFieldDecoratorDef
+    export function uploadTo(location:string) : ClassFieldDecoratorDef
+    export function ref(opt?:{ modelType?:TypeOf, model?:string, refId?:string, refLabel?:string, selfId?:string, queryType?:TypeOf, none?:boolean, }) : ClassFieldDecoratorDef
+    export type FormatMethods = "currency"|"bytes"|"icon"|"iconRounded"|"attachment"|"link"|"linkMailTo"|"linkTel"|"enumFlags"|"hidden"
+    export function format(method:FormatMethods, opt?:{ options?:string, locale?:string }) : ClassFieldDecoratorDef
+    
+    export enum IntlFormat { Number, DateTime, RelativeTime }
+    export enum NumberStyle { Undefined=0, Decimal, Currency, Percent, Unit, }
+    export enum DateStyle { Undefined=0, Full, Long, Medium, Short, }
+    export enum TimeStyle { Undefined=0, Full, Long, Medium, Short, }
+    export enum Numeric { Undefined=0, Always, Auto, }
+    
+    export enum DatePart { Undefined=0, Numeric, Digits2, }
+    export enum DateMonth { Undefined=0, Numeric, Digits2, Narrow, Short, Long, }
+    export enum DateText { Undefined=0, Narrow, Short, Long }
+    
+    export enum CurrencyDisplay { Undefined=0, Symbol, NarrowSymbol, Code, Name, }
+    export enum CurrencySign { Undefined=0, Accounting, Standard, }
+    export enum SignDisplay { Undefined=0, Always, Auto, ExceptZero, Negative, Never, }
+    export enum RoundingMode { Undefined=0, Ceil, Floor, Expand, Trunc, HalfCeil, HalfFloor, HalfExpand, HalfTrunc, HalfEven, }
+    
+    export enum UnitDisplay { Undefined=0, Long, Short, Narrow }
+    export enum Notation { Undefined=0, Standard, Scientific, Engineering, Compact, }
+    
+    export type IntlOptions = { locale?:string, options?:string, number?:NumberStyle, date?:DateStyle, time?:TimeStyle, numeric?:Numeric,
+        currency?:string, currencyDisplay?:CurrencyDisplay, currencySign?:CurrencySign, signDisplay?:SignDisplay, roundingMode?:RoundingMode,
+        unit?:string, unitDisplay?:UnitDisplay, notation?:Notation,
+        minimumIntegerDigits?:number, minimumFractionDigits?:number, maximumFractionDigits?:number, minimumSignificantDigits?:number, maximumSignificantDigits?:number, fractionalSecondDigits?:number, 
+        weekday?:DateText, era?:DateText, year?:DatePart, month?:DateMonth, day?:DatePart, hour?:DatePart, minute?:DatePart, second?:DatePart, 
+        timeZoneName?:DateText, timeZone?:string, hour12?:boolean
+    }
+    
+    export function intl(type:IntlFormat, opt?:IntlOptions) : ClassFieldDecoratorDef
+    export function intlNumber(number?:NumberStyle) : ClassFieldDecoratorDef
+    export function intlDateTime(date?:DateStyle, time?:TimeStyle) : ClassFieldDecoratorDef
+    export function intlRelativeTime(numeric?:Numeric) : ClassFieldDecoratorDef
+
+    //RequestAttrs & TypeAttrs & DataModelAttrs & RequestPropAttrs & DataModelPropAttrs
+    export class All {
+        // RequestAttrs
+        api:typeof api
+        apiResponse:typeof apiResponse
+        validateRequest:typeof validateRequest
+        validateIsAuthenticated:typeof validateIsAuthenticated
+        validateIsAdmin:typeof validateIsAdmin
+        validateAuthSecret:typeof validateAuthSecret
+        validateHasRole:typeof validateHasRole
+        validateHasRoles:typeof validateHasRoles
+        validateHasPermission:typeof validateHasPermission
+        validateHasPermissions:typeof validateHasPermissions
+        validateHasClaim:typeof validateHasClaim
+        validateHasScope:typeof validateHasScope
+        validateApiKey:typeof validateApiKey
+
+        queryDb:typeof queryDb
+        queryData:typeof queryData
+        autoFilter:typeof autoFilter
+        autoPopulate:typeof autoPopulate
+
+        route:typeof route
+        field:typeof field
+        tag:typeof tag
+        notes:typeof notes
+        
+        // Type and Attrs
+        dataContract:typeof dataContract
+        
+        // DataModelAttrs
+        schema:typeof schema
+        compositeKey:typeof compositeKey
+        preCreateTable:typeof preCreateTable
+        preDropTable:typeof preDropTable
+        postCreateTable:typeof postCreateTable
+        postDropTable:typeof postDropTable
+
+        namedConnection:typeof namedConnection
+        icon:typeof icon
+
+        // Class or Field Attrs
+        alias:typeof alias
+        meta:typeof meta // Type
+        flags:typeof flags // Enum
+        
+        // RequestPropAttrs
+        validate:typeof validate
+        validateNull:typeof validateNull
+        validateEmpty:typeof validateEmpty
+        validateEmail:typeof validateEmail
+        validateNotNull:typeof validateNotNull
+        validateNotEmpty:typeof validateNotEmpty
+        validateCreditCard:typeof validateCreditCard
+        validateLength:typeof validateLength
+        validateExactLength:typeof validateExactLength
+        validateMinimumLength:typeof validateMinimumLength
+        validateMaximumLength:typeof validateMaximumLength
+        validateLessThan:typeof validateLessThan
+        validateLessThanOrEqual:typeof validateLessThanOrEqual
+        validateGreaterThan:typeof validateGreaterThan
+        validateGreaterThanOrEqual:typeof validateGreaterThanOrEqual
+        validateScalePrecision:typeof validateScalePrecision
+        validateRegularExpression:typeof validateRegularExpression
+        validateEqualExpression:typeof validateEqualExpression
+        validateNotEqualExpression:typeof validateNotEqualExpression
+        validateInclusiveBetween:typeof validateInclusiveBetween
+        validateExclusiveBetween:typeof validateExclusiveBetween
+        allowReset:typeof allowReset
+        denyReset:typeof denyReset
+
+        queryDbField:typeof queryDbField
+        queryDataField:typeof queryDataField
+        autoUpdate:typeof autoUpdate
+        autoDefault:typeof autoDefault
+        autoMap:typeof autoMap
+        autoIgnore:typeof autoIgnore
+        autoApply:typeof autoApply
+
+        apiMember:typeof apiMember
+        apiAllowableValues:typeof apiAllowableValues
+        dataMember:typeof dataMember
+        input:typeof input
+        fieldCss:typeof fieldCss
+        uploadTo:typeof uploadTo
+
+        enumMember:typeof enumMember
+        
+        // DataModelPropAttrs
+        // alias:typeof alias
+        // meta:typeof meta
+        priority:typeof priority
+
+        primaryKey:typeof primaryKey
+        autoId:typeof autoId
+        autoIncrement:typeof autoIncrement
+        index:typeof index
+        compute:typeof compute
+        computed:typeof computed
+        persisted:typeof persisted
+        uniqueConstraint:typeof uniqueConstraint
+        addColumn:typeof addColumn
+        removeColumn:typeof removeColumn
+        belongTo:typeof belongTo
+        checkConstraint:typeof checkConstraint
+        customField:typeof customField
+        customSelect:typeof customSelect
+        customInsert:typeof customInsert
+        customUpdate:typeof customUpdate
+        decimalLength:typeof decimalLength
+        Default:typeof Default
+        description:typeof description
+        enumAsInt:typeof enumAsInt
+        excludeMetadata:typeof excludeMetadata
+        excludeFromDescription:typeof excludeFromDescription
+        explicitAutoQuery:typeof explicitAutoQuery
+        foreignKey:typeof foreignKey
+        ignore:typeof ignore
+        ignoreOnUpdate:typeof ignoreOnUpdate
+        ignoreOnInsert:typeof ignoreOnInsert
+        ignoreDataMember:typeof ignoreDataMember
+        reference:typeof reference
+        referenceField:typeof referenceField
+        references:typeof references
+        required:typeof required
+        returnOnInsert:typeof returnOnInsert
+        rowVersion:typeof rowVersion
+        unique:typeof unique
+
+        ref:typeof ref
+        format:typeof format
+        intl:typeof intl
+        intlNumber:typeof intlNumber
+        intlDateTime:typeof intlDateTime
+        intlRelativeTime:typeof intlRelativeTime
+    } 
+    export const Read : All
+    export const Write : All
+    export const Create : All
+    export const Update : All
+    export const Delete : All
+}
+
+export {}

package/dist/cs-apis.js

@@ -1,4 +1,4 @@
-import { getGroupName, splitCase } from "./utils.js";
+import { getGroupName } from "./utils.js";
 import { CSharpGenerator } from "./cs-gen.js";
 export class CSharpApiGenerator extends CSharpGenerator {
     toApiClass(op) {
@@ -78,12 +78,6 @@ export class CSharpApiGenerator extends CSharpGenerator {
     }
     generate(ast) {
         const groupName = getGroupName(ast);
-        const friendlyGroupName = splitCase(groupName);
-        ast.operations.forEach(op => {
-            if (!op.tags)
-                op.tags = [];
-            op.tags.push(friendlyGroupName);
-        });
         this.namespaces = Array.from(ast.namespaces);
         this.apis = ast.operations.map(x => this.toApiClass(x));
         this.classes = ast.types.filter(t => !t.isEnum).map(x => this.toClass(x));

package/dist/cs-ast.js

@@ -1,4 +1,4 @@
-import { plural, toPascalCase } from "./utils.js";
+import { getGroupName, leftPart, plural, rightPart, splitCase, toPascalCase } from "./utils.js";
 import { Icons } from "./icons.js";
 const sys = (name, genericArgs) => ({ name, namespace: "System", genericArgs });
 const sysObj = sys("object");
@@ -34,6 +34,153 @@ export class CSharpAst {
     commonValueTypes = [
         "int", "Int32", "long", "Int64", "string",
     ];
+    requestAttrs = [
+        'api',
+        'apiResponse',
+        'validateRequest',
+        'validateIsAuthenticated',
+        'validateIsAdmin',
+        'validateAuthSecret',
+        'validateHasRole',
+        'validateHasRoles',
+        'validateHasPermission',
+        'validateHasPermissions',
+        'validateHasClaim',
+        'validateHasScope',
+        'validateApiKey',
+        'queryDb',
+        'queryData',
+        'autoFilter',
+        'autoPopulate',
+        'route',
+        'field',
+        'tag',
+        'notes',
+        'meta',
+        'dataContract',
+    ].map(x => x.toLowerCase());
+    modelAttrs = [
+        'schema',
+        'compositeKey',
+        'preCreateTable',
+        'preDropTable',
+        'postCreateTable',
+        'postDropTable',
+        'namedConnection',
+        'alias',
+        'icon',
+        'meta',
+        'dataContract',
+    ].map(x => x.toLowerCase());
+    requestPropAttrs = [
+        'validate',
+        'validateNull',
+        'validateEmpty',
+        'validateEmail',
+        'validateNotNull',
+        'validateNotEmpty',
+        'validateCreditCard',
+        'validateLength',
+        'validateExactLength',
+        'validateMinimumLength',
+        'validateMaximumLength',
+        'validateLessThan',
+        'validateLessThanOrEqual',
+        'validateGreaterThan',
+        'validateGreaterThanOrEqual',
+        'validateScalePrecision',
+        'validateRegularExpression',
+        'validateEqualExpression',
+        'validateNotEqualExpression',
+        'validateInclusiveBetween',
+        'validateExclusiveBetween',
+        'allowReset',
+        'denyReset',
+        'queryDbField',
+        'queryDataField',
+        'autoUpdate',
+        'autoDefault',
+        'autoMap',
+        'autoIgnore',
+        'autoApply',
+        'apiMember',
+        'apiAllowableValues',
+        'dataMember',
+        'input',
+        'fieldCss',
+        'uploadTo',
+    ].map(x => x.toLowerCase());
+    get requestPropAttrsWithoutValidators() {
+        return this.requestPropAttrs.filter(x => !x.startsWith('validate'));
+    }
+    modelPropAttrs = [
+        'alias',
+        'meta',
+        'priority',
+        'primaryKey',
+        'autoId',
+        'autoIncrement',
+        'index',
+        'compute',
+        'computed',
+        'persisted',
+        'uniqueConstraint',
+        'addColumn',
+        'removeColumn',
+        'belongTo',
+        'checkConstraint',
+        'customField',
+        'customSelect',
+        'customInsert',
+        'customUpdate',
+        'decimalLength',
+        'Default',
+        'description',
+        'enumAsInt',
+        'excludeMetadata',
+        'excludeFromDescription',
+        'explicitAutoQuery',
+        'foreignKey',
+        'ignore',
+        'ignoreOnUpdate',
+        'ignoreOnInsert',
+        'ignoreDataMember',
+        'reference',
+        'referenceField',
+        'references',
+        'required',
+        'returnOnInsert',
+        'rowVersion',
+        'unique',
+        'dataMember',
+        'ref',
+        'format',
+        'intl',
+        'intlNumber',
+        'intlDateTime',
+        'intlRelativeTime',
+    ].map(x => x.toLowerCase());
+    // Ignore properties with these attributes on APIs
+    ignoreCreateProps = [
+        'autoIncrement',
+        'references',
+        'compute',
+        'computed',
+    ].map(x => x.toLowerCase());
+    ignoreUpdateProps = [
+        'references',
+        'compute',
+        'computed',
+    ].map(x => x.toLowerCase());
+    // Validators that should be on Create but not optional Update APIs
+    ignoreUpdateValidators = [
+        'validateNull',
+        'validateNotNull',
+        'validateEmpty',
+        'validateNotEmpty',
+    ].map(x => x.toLowerCase());
+    ignoreReadValidators = this.requestPropAttrs.filter(x => x.startsWith('validate')).map(x => x.toLowerCase());
+    ignoreDeleteValidators = this.requestPropAttrs.filter(x => x.startsWith('validate')).map(x => x.toLowerCase());
     unwrap(type) {
         if (type.endsWith("?")) {
             return type.substring(0, type.length - 1);
@@ -76,19 +223,26 @@ export class CSharpAst {
         return this.typeMap[type] ?? { name: type, namespace: "MyApp" };
     }
     csharpAttribute(attr) {
-        const to = { name: toPascalCase(attr.name) };
+        const attrName = attr.name.includes('.')
+            ? rightPart(attr.name, '.')
+            : attr.name;
+        const to = { name: toPascalCase(attrName) };
         const attrType = (value) => typeof value == 'string'
-            ? (`${value}`.startsWith('typeof') ? "Type" : "string")
+            ? ((value.startsWith('typeof(') || value.startsWith('nameof(')) && value.endsWith(')')
+                ? "constant" :
+                value.match(/^[A-Z][A-Za-z0-9_]+\.[A-Z][A-Za-z0-9_]+$/) //Axx.Bxx
+                    ? "constant"
+                    : "string")
             : typeof value == "object"
                 ? (value instanceof Date ? "string" : Array.isArray(value) ? "array" : "object")
                 : typeof value;
         if (attr.constructorArgs?.length) {
             to.constructorArgs = attr.constructorArgs.map(x => {
-                const type = attrType(x.value);
+                const type = attrType(x);
                 return {
                     name: 'String',
                     type,
-                    value: `${x.value}`
+                    value: `${x}`
                 };
             });
         }
@@ -102,21 +256,27 @@ export class CSharpAst {
                 };
             });
         }
+        if (attr.name.includes('.')) {
+            to.namespace = leftPart(attr.name, '.');
+        }
         return to;
     }
     addMetadataType(cls) {
         const type = {
             name: this.toCsName(cls.name),
             namespace: "MyApp",
-            description: cls.comment,
             properties: cls.properties.map(p => {
                 const type = this.csharpType(p.type, p.name);
                 const prop = {
                     name: this.toCsName(p.name),
                     type: p.optional ? this.nullable(type.name) : type.name,
-                    namespace: type.namespace,
-                    description: p.comment,
                 };
+                if (type.namespace) {
+                    prop.namespace = type.namespace;
+                }
+                if (p.comment) {
+                    prop.description = p.comment;
+                }
                 if (prop.name === 'Id') {
                     prop.isPrimaryKey = true;
                 }
@@ -145,6 +305,12 @@ export class CSharpAst {
                 return prop;
             }),
         };
+        if (cls.comment) {
+            type.description = cls.comment;
+        }
+        if (cls.extends) {
+            type.inherits = { name: this.toCsName(cls.extends) };
+        }
         if (cls.annotations?.length) {
             type.attributes = cls.annotations.map(x => this.csharpAttribute(x));
         }
@@ -389,7 +555,86 @@ export class CSharpAst {
             }
         }
     }
+    onlyAttrs(attrs, only) {
+        if (!attrs)
+            return;
+        return attrs.filter(x => only.includes(x.name.toLowerCase()));
+    }
+    attrsFor(dtoType, attrType, attrs) {
+        const requestAttrs = this.requestAttrs;
+        const requestPropAttrs = this.requestPropAttrs;
+        const modelAttrs = this.modelAttrs;
+        const modelPropAttrs = this.modelPropAttrs;
+        const isRequest = ["Read", "Create", "Update", "Delete"].includes(dtoType);
+        const validAttrs = attrType === "Type"
+            ? isRequest
+                ? requestAttrs
+                : modelAttrs
+            : isRequest
+                ? requestPropAttrs
+                : modelPropAttrs;
+        const ignoreValidators = attrType === "Prop"
+            ? dtoType === "Update"
+                ? this.ignoreUpdateValidators
+                : dtoType === "Read"
+                    ? this.ignoreReadValidators
+                    : dtoType === "Delete"
+                        ? this.ignoreDeleteValidators
+                        : []
+            : [];
+        function shouldInclude(attr, dtoType) {
+            if (!validAttrs.includes(attr.name.toLowerCase()))
+                return false;
+            const ns = attr.namespace;
+            if (ns) {
+                if (ns == "All")
+                    return true;
+                if (ns == "Read")
+                    return dtoType == "Read";
+                if (ns == "Create")
+                    return dtoType == "Create";
+                if (ns == "Update")
+                    return dtoType == "Update";
+                if (ns == "Delete")
+                    return dtoType == "Delete";
+                if (ns == "Write")
+                    return ["Create", "Update", "Delete"].includes(dtoType);
+                return false;
+            }
+            else {
+                const nameLower = attr.name.toLowerCase();
+                if (isRequest) {
+                    if (attrType === "Type") {
+                        return requestAttrs.includes(nameLower);
+                    }
+                    else if (attrType === "Prop") {
+                        if (ignoreValidators.length && ignoreValidators.includes(nameLower))
+                            return false;
+                        return requestPropAttrs.includes(nameLower);
+                    }
+                }
+                else {
+                    if (attrType === "Type") {
+                        return modelAttrs.includes(nameLower);
+                    }
+                    else if (attrType === "Prop") {
+                        return modelPropAttrs.includes(nameLower);
+                    }
+                }
+            }
+            return true;
+        }
+        const to = [];
+        for (const attr of attrs || []) {
+            if (shouldInclude(attr, dtoType)) {
+                to.push(attr);
+            }
+        }
+        return to;
+    }
     createAutoCrudApis() {
+        const groupName = getGroupName(this.result);
+        const friendlyGroupName = splitCase(groupName);
         for (const type of this.classes) {
             const hasPk = type.properties?.some(x => x.isPrimaryKey);
             if (!hasPk)
@@ -400,6 +645,12 @@ export class CSharpAst {
             const pk = type.properties?.find(x => x.isPrimaryKey);
             const dataModel = { name: type.name, namespace: type.name };
             const isAuditBase = type.inherits?.name === 'AuditBase';
+            const existingTag = type.attributes?.find(x => x.name.toLowerCase() === 'tag');
+            const tags = !existingTag ? [friendlyGroupName] : undefined;
+            const emptyTag = existingTag?.constructorArgs?.[0]?.value === '';
+            if (emptyTag) {
+                type.attributes = type.attributes.filter(x => x !== existingTag);
+            }
             const inputTagAttrs = [{
                     name: "Input",
                     args: [{ name: "Type", type: "string", value: "tag" }]
@@ -408,21 +659,14 @@ export class CSharpAst {
                     name: "FieldCss",
                     args: [{ name: "Field", type: "string", value: "col-span-12" }]
                 }];
-            const ignoreDtoAttrs = ['AutoIncrement'];
-            const idsProps = pk
-                ? [
-                    Object.assign({}, pk, {
-                        type: `${this.nullable(pk.type)}`,
-                        attributes: pk.attributes?.filter(a => !ignoreDtoAttrs.includes(a.name)),
-                    }),
-                    {
-                        name: `${pk.name}s`,
-                        type: "List`1?",
-                        namespace: "System.Collections.Generic",
-                        genericArgs: [pk.type]
-                    }
-                ]
-                : [];
+            const idsProp = pk
+                ? {
+                    name: `${pk.name}s`,
+                    type: "List`1?",
+                    namespace: "System.Collections.Generic",
+                    genericArgs: [pk.type]
+                }
+                : undefined;
             if (!queryApi) {
                 queryApi = {
                     method: "GET",
@@ -436,7 +680,16 @@ export class CSharpAst {
                             namespace: "ServiceStack",
                             genericArgs: [type.name]
                         },
-                        properties: idsProps,
+                        properties: pk
+                            ? [
+                                Object.assign({}, pk, {
+                                    type: this.nullable(pk.type),
+                                    attributes: this.attrsFor("Read", "Prop", pk.attributes),
+                                }),
+                                idsProp
+                            ]
+                            : [],
+                        attributes: this.attrsFor("Read", "Type", type.attributes),
                     },
                     returnType: {
                         name: "QueryResponse`1",
@@ -446,25 +699,23 @@ export class CSharpAst {
                     dataModel,
                 };
                 if (isAuditBase) {
-                    if (!queryApi.request.attributes)
-                        queryApi.request.attributes = [];
-                    // [AutoApply(Behavior.AuditQuery)]
-                    queryApi.request.attributes.push({
-                        name: "AutoApply",
-                        constructorArgs: [{
-                                name: "name",
-                                type: "constant",
-                                value: "Behavior.AuditQuery"
-                            }]
-                    });
+                    if (!queryApi.request.attributes?.find(x => x.name === 'AutoApply')) {
+                        // [AutoApply(Behavior.AuditQuery)]
+                        queryApi.request.attributes.push({
+                            name: "AutoApply",
+                            constructorArgs: [{
+                                    name: "name",
+                                    type: "constant",
+                                    value: "Behavior.AuditQuery"
+                                }]
+                        });
+                    }
                 }
                 this.result.operations.push(queryApi);
             }
             let createName = `Create${type.name}`;
             let createApi = this.result.operations.find(x => x.request.name === createName);
             if (!createApi) {
-                const ignorePropsWithAttrs = ['AutoIncrement', 'Reference'];
-                const ignoreAttrs = [];
                 createApi = {
                     method: "POST",
                     actions: ["ANY"],
@@ -477,12 +728,13 @@ export class CSharpAst {
                                 genericArgs: [type.name]
                             }],
                         properties: type.properties
-                            .filter(x => !x.attributes?.some(a => ignorePropsWithAttrs.includes(a.name))).map(x => Object.assign({}, x, {
+                            .filter(x => !x.attributes?.some(a => this.ignoreCreateProps.includes(a.name.toLowerCase()))).map(x => Object.assign({}, x, {
                             type: x.isPrimaryKey
                                 ? x.type
                                 : `${x.type}`,
-                            attributes: x.attributes?.filter(a => !ignoreAttrs.includes(a.name)),
+                            attributes: this.attrsFor("Create", "Prop", x.attributes),
                         })),
+                        attributes: this.attrsFor("Create", "Type", type.attributes),
                     },
                     returnType: {
                         name: "IdResponse",
@@ -494,42 +746,50 @@ export class CSharpAst {
                     if (prop.isRequired) {
                         if (!prop.attributes)
                             prop.attributes = [];
+                        var hasAnyValidateAttrs = prop.attributes.some(x => x.name.toLowerCase().startsWith('validate'));
                         if (prop.type === 'string') {
-                            prop.attributes.push({
-                                name: "ValidateNotEmpty",
-                            });
+                            if (!hasAnyValidateAttrs) {
+                                prop.attributes.push({
+                                    name: "ValidateNotEmpty",
+                                });
+                            }
                         }
                         else if (this.integerTypes.includes(prop.type)) {
-                            prop.attributes.push({
-                                name: "ValidateGreaterThan",
-                                constructorArgs: [{ name: "value", type: "int", value: "0" }]
-                            });
+                            if (!hasAnyValidateAttrs) {
+                                prop.attributes.push({
+                                    name: "ValidateGreaterThan",
+                                    constructorArgs: [{ name: "value", type: "int", value: "0" }]
+                                });
+                            }
                         }
                         else if (prop.type === 'List`1' && this.commonValueTypes.includes(prop.genericArgs[0])) {
                             prop.attributes.push(...inputTagAttrs);
                         }
+                        const emptyValidateAttr = prop.attributes.find(x => x.name.toLowerCase() === 'validate');
+                        if (emptyValidateAttr && emptyValidateAttr.constructorArgs?.[0]?.value === '') {
+                            prop.attributes = prop.attributes.filter(x => x !== emptyValidateAttr);
+                        }
                     }
                 }
                 if (isAuditBase) {
                     createApi.requiresAuth = true;
-                    if (!createApi.request.attributes)
-                        createApi.request.attributes = [];
-                    // [AutoApply(Behavior.AuditCreate)]
-                    createApi.request.attributes.push({
-                        name: "AutoApply",
-                        constructorArgs: [{
-                                name: "name",
-                                type: "constant",
-                                value: "Behavior.AuditCreate"
-                            }]
-                    });
+                    if (!createApi.request.attributes?.find(x => x.name === 'AutoApply')) {
+                        // [AutoApply(Behavior.AuditCreate)]
+                        createApi.request.attributes.push({
+                            name: "AutoApply",
+                            constructorArgs: [{
+                                    name: "name",
+                                    type: "constant",
+                                    value: "Behavior.AuditCreate"
+                                }]
+                        });
+                    }
                 }
                 this.result.operations.push(createApi);
             }
             let updateName = `Update${type.name}`;
             let updateApi = this.result.operations.find(x => x.request.name === updateName);
             if (!updateApi) {
-                const ignoreAttrs = ['AutoIncrement'];
                 updateApi = {
                     method: "PATCH",
                     actions: ["ANY"],
@@ -541,12 +801,13 @@ export class CSharpAst {
                                 namespace: "ServiceStack",
                                 genericArgs: [type.name]
                             }],
-                        properties: type.properties?.filter(x => !x.attributes?.some(x => x.name === 'References')).map(x => Object.assign({}, x, {
+                        properties: type.properties?.filter(x => !x.attributes?.some(x => this.ignoreUpdateProps.includes(x.name.toLowerCase()))).map(x => Object.assign({}, x, {
                             type: x.isPrimaryKey
                                 ? x.type
                                 : `${this.nullable(x.type)}`,
-                            attributes: x.attributes?.filter(a => !ignoreAttrs.includes(a.name)),
+                            attributes: this.attrsFor("Update", "Prop", x.attributes),
                         })),
+                        attributes: this.attrsFor("Update", "Type", type.attributes),
                     },
                     returnType: {
                         name: "IdResponse",
@@ -565,17 +826,17 @@ export class CSharpAst {
                 }
                 if (isAuditBase) {
                     updateApi.requiresAuth = true;
-                    if (!updateApi.request.attributes)
-                        updateApi.request.attributes = [];
-                    // [AutoApply(Behavior.AuditModify)]
-                    updateApi.request.attributes.push({
-                        name: "AutoApply",
-                        constructorArgs: [{
-                                name: "name",
-                                type: "constant",
-                                value: "Behavior.AuditModify"
-                            }]
-                    });
+                    if (!updateApi.request.attributes?.find(x => x.name === 'AutoApply')) {
+                        // [AutoApply(Behavior.AuditModify)]
+                        updateApi.request.attributes.push({
+                            name: "AutoApply",
+                            constructorArgs: [{
+                                    name: "name",
+                                    type: "constant",
+                                    value: "Behavior.AuditModify"
+                                }]
+                        });
+                    }
                 }
                 this.result.operations.push(updateApi);
             }
@@ -593,29 +854,50 @@ export class CSharpAst {
                                 namespace: "ServiceStack",
                                 genericArgs: [type.name]
                             }],
-                        properties: idsProps,
+                        properties: pk
+                            ? [
+                                Object.assign({}, pk, {
+                                    type: this.nullable(pk.type),
+                                    attributes: this.attrsFor("Delete", "Prop", pk.attributes),
+                                }),
+                                idsProp
+                            ]
+                            : [],
+                        attributes: this.attrsFor("Delete", "Type", type.attributes),
                     },
                     returnsVoid: true,
                     dataModel,
                 };
                 if (isAuditBase) {
                     deleteApi.requiresAuth = true;
-                    if (!deleteApi.request.attributes)
-                        deleteApi.request.attributes = [];
-                    // [AutoApply(Behavior.AuditSoftDelete)]
-                    deleteApi.request.attributes.push({
-                        name: "AutoApply",
-                        constructorArgs: [{
-                                name: "name",
-                                type: "constant",
-                                value: "Behavior.AuditSoftDelete"
-                            }]
-                    });
+                    if (!deleteApi.request.attributes?.find(x => x.name === 'AutoApply')) {
+                        // [AutoApply(Behavior.AuditSoftDelete)]
+                        deleteApi.request.attributes.push({
+                            name: "AutoApply",
+                            constructorArgs: [{
+                                    name: "name",
+                                    type: "constant",
+                                    value: "Behavior.AuditSoftDelete"
+                                }]
+                        });
+                    }
                 }
                 this.result.operations.push(deleteApi);
             }
         }
     }
+    filterModelAttributes() {
+        for (const type of this.classes) {
+            if (type.attributes?.length) {
+                type.attributes = this.attrsFor("Model", "Type", type.attributes);
+            }
+            type.properties?.forEach(p => {
+                if (p.attributes?.length) {
+                    p.attributes = this.attrsFor("Model", "Prop", p.attributes);
+                }
+            });
+        }
+    }
     // Add Icon for BuiltIn UIs and AutoQueryGrid to known type names
     addIconsToKnownTypes() {
         for (const type of this.typesWithPrimaryKeys) {
@@ -623,8 +905,14 @@ export class CSharpAst {
             if (icon) {
                 if (!type.attributes)
                     type.attributes = [];
-                if (type.attributes.some(x => x.name === 'Icon'))
-                    continue;
+                const existingIcon = type.attributes.find(x => x.name === 'Icon');
+                if (existingIcon) {
+                    // remove empty icon
+                    if (existingIcon.constructorArgs?.[0]?.value === '') {
+                        type.attributes = type.attributes.filter(x => x !== existingIcon);
+                    }
+                    return;
+                }
                 type.attributes.push({
                     name: "Icon",
                     args: [{ name: "Svg", type: "string", value: icon }]
@@ -696,6 +984,7 @@ export class CSharpAst {
         this.hideReferenceProperties();
         this.replaceUserReferencesWithAuditTables();
         this.createAutoCrudApis();
+        this.filterModelAttributes();
     }
     parse(ast) {
         const classes = ast.classes.concat(ast.interfaces);

package/dist/cs-gen.js

@@ -41,7 +41,7 @@ export class CSharpGenerator {
                 body += value;
             }
         }
-        if (!body && attr.args?.length) {
+        if (attr.args?.length) {
             for (const arg of attr.args) {
                 this.addNamespace(arg.namespace);
                 if (body)

package/dist/index.js

@@ -57,7 +57,7 @@ function parseArgs(...args) {
                     break;
             }
         }
-        else if (ret.type === "help" && ["help", "info", "init", "ls", "rm", "update", "accept"].includes(arg)) {
+        else if (ret.type === "help" && ["help", "info", "init", "ls", "add", "rm", "update", "accept"].includes(arg)) {
             if (arg == "help")
                 ret.type = "help";
             else if (arg == "info")
@@ -82,6 +82,10 @@ function parseArgs(...args) {
                 ret.type = "list";
                 ret.list = args[++i];
             }
+            else if (arg == "add") {
+                ret.type = "add";
+                ret.add = args[++i];
+            }
             else if (arg == "accept") {
                 ret.type = "accept";
                 ret.accept = args[++i];
@@ -208,6 +212,24 @@ Options:
             process.exit(0);
         }
     }
+    if (command.type === "add") {
+        if (command.add == "types" || command.add?.startsWith("api")) {
+            const apiFile = path.join(import.meta.dirname, 'api.d.ts');
+            if (!fs.existsSync(apiFile)) {
+                console.log(`Could not find: ${apiFile}`);
+                process.exit(1);
+            }
+            const toFile = path.join(info.serviceModelDir, 'api.d.ts');
+            fs.copyFileSync(apiFile, toFile);
+            console.log(`Added: ${toFile}`);
+            process.exit(0);
+        }
+        else {
+            console.log(`Unknown add command: ${command.add}`);
+            console.log(`Usage:  add types`);
+            process.exit(1);
+        }
+    }
     function assertTsdPath(tsdFile) {
         const tryPaths = [
             path.join(process.cwd(), tsdFile),
@@ -320,6 +342,13 @@ Options:
         }
         fs.unlinkSync(tsdPath);
         console.log(`Removed: ${tsdPath}`);
+        const serviceModelDir = path.dirname(tsdPath);
+        const tsds = fs.readdirSync(serviceModelDir).filter(x => x.endsWith('.d.ts'));
+        if (tsds.length == 1 && tsds[0] == 'api.d.ts') {
+            const typesApiPath = path.join(serviceModelDir, 'api.d.ts');
+            fs.unlinkSync(typesApiPath);
+            console.log(`Removed: ${typesApiPath}`);
+        }
         process.exit(0);
     }
     if (command.type == "accept") {
@@ -608,15 +637,18 @@ function chooseFile(ctx, info, gist, comamnd) {
     const migrationFileName = path.basename(migrationPath);
     const migrationCls = leftPart(migrationFileName, '.');
     const migrationContent = replaceMyApp(csMigrationFiles[Object.keys(csMigrationFiles)[0]].replaceAll('Migration1000', migrationCls), info.projectName);
-    const sb = [];
-    sb.push(`/*prompt: ${titleBar.content.replaceAll('/*', '').replaceAll('*/', '')}`);
-    sb.push(`api:       ~/${path.join(relativeServiceModelDir, apiFileName)}`);
-    sb.push(`migration: ~/${path.join(relativeMigrationDir, migrationFileName)}`);
-    sb.push(`*/`);
-    sb.push('');
-    sb.push(tsd);
+    const sb = [
+        `/// <reference path="./api.d.ts" />`,
+        `/*prompt: ${titleBar.content.replaceAll('/*', '').replaceAll('*/', '')}`,
+        `api:       ~/${path.join(relativeServiceModelDir, apiFileName)}`,
+        `migration: ~/${path.join(relativeMigrationDir, migrationFileName)}`,
+        `*/`,
+        '',
+        tsd,
+    ];
     const tsdContent = sb.join('\n');
     const tsdFileName = `${groupName}.d.ts`;
+    const typesApiPath = path.join(info.slnDir, relativeServiceModelDir, `api.d.ts`);
     const fullTsdPath = path.join(info.slnDir, relativeServiceModelDir, tsdFileName);
     const fullApiPath = path.join(info.slnDir, relativeServiceModelDir, apiFileName);
     const fullMigrationPath = path.join(info.slnDir, relativeMigrationDir, migrationFileName);
@@ -635,6 +667,8 @@ function chooseFile(ctx, info, gist, comamnd) {
         fs.writeFileSync(fullMigrationPath, migrationContent, { encoding: 'utf-8' });
         console.log(`Saved: ${fullMigrationPath}`);
     }
+    const apiFile = path.join(import.meta.dirname, 'api.d.ts');
+    fs.writeFileSync(typesApiPath, fs.readFileSync(apiFile, 'utf-8'));
     const script = path.basename(process.argv[1]);
     console.log(`\nTo regenerate classes, update '${tsdFileName}' then run:`);
     console.log(`$ ${script} ${tsdFileName}`);

package/dist/ts-parser.js

@@ -4,7 +4,8 @@ export class TypeScriptParser {
     static ENUM_PATTERN = /enum\s+(\w+)\s*{([^}]*)}/g;
     static PROPERTY_PATTERN = /(?:(?<modifier>private|public|protected|readonly)\s+)*(?<name>\w+)(?<optional>\?)?\s*:\s*(?<type>[\w<>[\],\s]+)(?<union>\|\s*[\w<>[\],|,\s]+)?\s*;?/;
     static ENUM_MEMBER_PATTERN = /(\w+)\s*(?:=\s*("[^"]*"|'[^']*'|\d+|[^,\n]+))?\s*/;
-    static ANNOTATION_PATTERN = /@\w+\(.*\)/;
+    // private static readonly ANNOTATION_PATTERN = /@(\w+\.?\w*)\s*\((.*)\)/
+    static ANNOTATION_PATTERN = /@([A-Za-z_][A-Za-z0-9_]*\.?[A-Za-z_]?[A-Za-z0-9_]*)\s*\((.*)\)/;
     classes = [];
     interfaces = [];
     enums = [];
@@ -260,7 +261,7 @@ export class TypeScriptParser {
 }
 export function parseAnnotation(annotation) {
     // Match @name and everything inside ()
-    const regex = /@(\w+)\s*\((.*)\)/;
+    const regex = /@(\w+\.?\w*)\s*\((.*)\)/;
     const match = annotation.match(regex);
     if (!match)
         return null;

package/dist/tsd-gen.js

@@ -32,6 +32,12 @@ export class TsdGenerator {
         return `${prefix}@${attr.name}(${sbArgs.join(',')})`;
     }
     toInterface(ast) {
+        return this.toType(ast, 'interface');
+    }
+    toClass(ast) {
+        return this.toType(ast, 'class');
+    }
+    toType(ast, type) {
         const sb = [];
         if (ast.comment) {
             sb.push(ast.comment.split('\n').map(x => `// ${x}`).join('\n'));
@@ -42,7 +48,7 @@ export class TsdGenerator {
             }
         }
         const extend = ast.extends ? ` extends ${ast.extends}` : '';
-        sb.push(`export interface ${ast.name}${extend} {`);
+        sb.push(`export ${type} ${ast.name}${extend} {`);
         for (const prop of ast.properties) {
             if (prop.comment) {
                 sb.push(prop.comment.split('\n').map(x => `  // ${x}`).join('\n'));
@@ -76,7 +82,7 @@ export class TsdGenerator {
         sb.push('}');
         return sb.join('\n');
     }
-    generate(ast) {
+    generate(ast, type = 'interface') {
         this.ast = ast;
         const sb = [];
         for (const cls of ast.enums ?? []) {
@@ -84,12 +90,12 @@ export class TsdGenerator {
             sb.push('');
         }
         for (const cls of ast.interfaces ?? []) {
-            sb.push(this.toInterface(cls));
+            sb.push(this.toType(cls, type));
             sb.push('');
         }
         for (const cls of ast.classes ?? []) {
             const iface = this.clsToInterface(cls);
-            sb.push(this.toInterface(iface));
+            sb.push(this.toType(iface, type));
             sb.push('');
         }
         const tsd = sb.join('\n');
@@ -154,6 +160,6 @@ export class TsdDataModelGenerator extends TsdGenerator {
         if (ast.interfaces) {
             ast.interfaces = ast.interfaces.filter(x => x.name !== 'User');
         }
-        return super.generate(ast);
+        return super.generate(ast, "class");
     }
 }

package/dist/utils.js

@@ -113,6 +113,14 @@ export function leftPart(s, needle) {
         ? s
         : s.substring(0, pos);
 }
+export function rightPart(s, needle) {
+    if (s == null)
+        return null;
+    let pos = s.indexOf(needle);
+    return pos == -1
+        ? s
+        : s.substring(pos + needle.length);
+}
 export function splitCase(t) {
     return typeof t != 'string' ? t : t.replace(/([A-Z]|[0-9]+)/g, ' $1').replace(/_/g, ' ').trim();
 }
@@ -126,13 +134,13 @@ export function tsdWithPrompt(tsd, prompt) {
     return `/*prompt:  ${prompt}\n*/\n\n${tsd}`;
 }
 export function tsdWithoutPrompt(tsd) {
-    return tsd.trim().startsWith('/*prompt:')
+    return tsd.includes('/*prompt:')
         ? tsd.substring(tsd.indexOf('*/') + 2).trim()
         : tsd;
 }
 export function parseTsdHeader(tsd) {
     const header = tsd.includes('/*prompt:')
-        ? leftPart(tsd, '*/').replace('/*prompt:', '').trim()
+        ? leftPart(rightPart(tsd, '/*prompt:'), '*/').trim()
         : null;
     if (!header)
         return null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "okai",
   "type": "module",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "bin": "./dist/okai.js",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -12,7 +12,7 @@
     "import": "./dist/index.js"
   },
   "scripts": {
-    "build": "bun run clean && tsc && chmod +x ./dist/okai.js",
+    "build": "bun run clean && tsc && shx cp ./src/api.d.ts ./dist && chmod +x ./dist/okai.js",
     "build-bun": "bun run clean && bun build.ts",
     "clean": "shx rm -rf ./dist",
     "test": "bun test --",