@omnifyjp/ts 6.0.6 → 6.2.0

package/dist/cli.js

@@ -233,6 +233,11 @@ program
             mkdirSync(dirname(filePath), { recursive: true });
             if (!file.overwrite && existsSync(filePath)) {
                 phpSkipped++;
+                // The file predates something the template now needs. Say so once,
+                // naming the file and the line, rather than rewriting user code.
+                if (file.expects && !readFileSync(filePath, 'utf-8').includes(file.expects.needle)) {
+                    console.warn(`[omnify-ts] ${relative(configDir, filePath)}: ${file.expects.hint}`);
+                }
                 continue;
             }
             // Issue #98 v5.8.18 / #99 v5.8.19: skip user-editable stub

package/dist/interface-generator.d.ts

@@ -17,7 +17,6 @@ export declare function toSnakeCase(str: string): string;
  * unconditionally produced `table_session_id_id` (issue #149).
  */
 export declare function toFkColumnName(propertyName: string): string;
-/** Gets TypeScript type for a property. */
 export declare function getPropertyType(property: PropertyDefinition, allSchemas: Record<string, SchemaDefinition>): string;
 /**
  * Convert a property to TSProperty array.

package/dist/interface-generator.js

@@ -63,12 +63,29 @@ function getIdType(options) {
     return 'BigInt';
 }
 /** Gets TypeScript type for a property. */
+/**
+ * The interface name to write for a relation target, or `unknown` when the
+ * target lives outside the generated schema set (external `targetNamespace`
+ * models). Imports are collected from the same schema set, so anything absent
+ * here would be referenced without ever being imported.
+ */
+function resolveTargetName(target, allSchemas) {
+    if (!target || !(target in allSchemas)) {
+        return 'unknown';
+    }
+    return target;
+}
 export function getPropertyType(property, allSchemas) {
     if (property.type === 'File') {
         return property.multiple ? 'OmnifyFile[]' : 'OmnifyFile | null';
     }
     if (property.type === 'Association') {
-        const targetName = property.target ?? 'unknown';
+        // A target outside the schema set (an external model reached through
+        // `targetNamespace`, e.g. the app's own User) has no generated interface
+        // and therefore no import. Naming it anyway emits `user?: User` against an
+        // identifier nothing declares — TS2304 in every consumer. `unknown` is the
+        // honest type for a shape this generator cannot see.
+        const targetName = resolveTargetName(property.target, allSchemas);
         switch (property.relation) {
             case 'OneToOne':
             case 'ManyToOne':
@@ -78,7 +95,9 @@ export function getPropertyType(property, allSchemas) {
                 return `${targetName}[]`;
             case 'MorphTo':
                 if (property.targets && property.targets.length > 0) {
-                    return property.targets.join(' | ');
+                    return property.targets
+                        .map(target => resolveTargetName(target, allSchemas))
+                        .join(' | ');
                 }
                 return 'unknown';
             case 'MorphOne':
@@ -162,7 +181,9 @@ export function propertyToTSProperties(propertyName, property, schema, allSchema
     // Handle Association: MorphTo — creates _type, _id, and relation properties
     if (property.type === 'Association' && property.relation === 'MorphTo' && property.targets && property.targets.length > 0) {
         const targetUnion = property.targets.map(t => `'${t}'`).join(' | ');
-        const relationUnion = property.targets.join(' | ');
+        const relationUnion = property.targets
+            .map(target => resolveTargetName(target, allSchemas))
+            .join(' | ');
         return [
             {
                 name: `${propertyName}_type`,
@@ -186,7 +207,7 @@ export function propertyToTSProperties(propertyName, property, schema, allSchema
     }
     // Handle Association: ManyToOne / OneToOne (owning side) — creates FK _id and relation
     if (property.type === 'Association' && (property.relation === 'ManyToOne' || property.relation === 'OneToOne') && !property.mappedBy) {
-        const targetName = property.target ?? 'unknown';
+        const targetName = resolveTargetName(property.target, allSchemas);
         // Determine FK type from target schema
         let fkType = 'number';
         const targetSchema = property.target ? allSchemas[property.target] : undefined;

package/dist/php/model-generator.js

@@ -15,15 +15,105 @@ export function generateModels(reader, config) {
     for (const [name, schema] of Object.entries(reader.getProjectObjectSchemas())) {
         files.push(...generateForSchema(name, schema, reader, config));
     }
-    // Package schemas: user model only (extends package model)
+    // Package schemas: user model only (extends package model), plus a trait
+    // carrying anything a project-level `kind: extend` added to them (#164).
     for (const [name, schema] of Object.entries(reader.getPackageObjectSchemas())) {
         const pkgNs = reader.resolveModelNamespace(name, config.models.namespace);
         if (pkgNs !== config.models.namespace) {
-            files.push(generatePackageUserModel(name, pkgNs, config));
+            const extended = extendedPropertyNames(schema);
+            if (extended.length > 0) {
+                files.push(generateExtendAttributesTrait(name, schema, extended, reader, config));
+            }
+            files.push(generatePackageUserModel(name, pkgNs, config, extended.length > 0));
         }
     }
     return files;
 }
+/**
+ * The properties a project-level `kind: extend` added to a schema, in merge
+ * order, keeping only the ones the schema still declares.
+ */
+function extendedPropertyNames(schema) {
+    const declared = schema.properties ?? {};
+    return (schema.extendedProperties ?? []).filter(name => declared[name] !== undefined);
+}
+/**
+ * A trait carrying the columns a project-level `kind: extend` added to a
+ * PACKAGE-owned schema (#164).
+ *
+ * The package's own generate run writes that model from the package's schemas
+ * alone; it cannot see a consumer's extend, so `$fillable` and `casts()` there
+ * are missing the added columns. The migration has them — the column exists —
+ * so `$model->new_column = x` is silently dropped by mass-assignment guarding
+ * and a Json column reads back as a raw string. The extend is only half
+ * applied, and nothing says so.
+ *
+ * It is written here, in the CONSUMER's own namespace, rather than back into
+ * the package's model. Writing into the package directory would work in a
+ * monorepo and silently do nothing once that package is installed under
+ * `vendor/`, where the next `composer install` removes it.
+ *
+ * `initialize<TraitName>()` is Laravel's own hook: `Model::__construct` calls
+ * `initializeTraits()`, which invokes it on every used trait. `mergeFillable` /
+ * `mergeCasts` add to what the parent declares instead of replacing it, which a
+ * redeclared `protected $fillable` in the child would do.
+ */
+function generateExtendAttributesTrait(name, schema, extended, reader, config) {
+    const modelName = toPascalCase(name);
+    const traitName = extendAttributesTraitName(name);
+    const properties = (schema.properties ?? {});
+    const expandedProperties = reader.getExpandedProperties(name);
+    // The same two builders the BaseModel uses, over the extended properties
+    // only. Sharing them is the point: a column the BaseModel would have made
+    // fillable, or cast, is made fillable and cast the same way here.
+    const fillable = buildFillable(properties, expandedProperties, extended)
+        .split('\n')
+        .filter(line => line.trim() !== '')
+        .map(line => `            ${line.trim()}`)
+        .join('\n');
+    const casts = buildCasts(properties, expandedProperties, extended, reader, config)
+        .split('\n')
+        .filter(line => line.trim() !== '')
+        .map(line => `            ${line.trim()}`)
+        .join('\n');
+    const body = [];
+    if (fillable !== '') {
+        body.push(`        $this->mergeFillable([\n${fillable}\n        ]);`);
+    }
+    if (casts !== '') {
+        body.push(`        $this->mergeCasts([\n${casts}\n        ]);`);
+    }
+    const content = `<?php
+
+namespace ${config.models.namespace}\\Concerns;
+
+/**
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+
+/**
+ * Columns this project's \`kind: extend\` added to the ${modelName} schema.
+ *
+ * ${modelName} is owned by a package, so the package's own model cannot know
+ * about them. Used by ${config.models.namespace}\\${modelName}.
+ */
+trait ${traitName}
+{
+    /** Called by Laravel's Model::initializeTraits() from the constructor. */
+    public function initialize${traitName}(): void
+    {
+${body.join('\n\n')}
+    }
+}
+`;
+    return baseFile(`${config.models.path}/Concerns/${traitName}.php`, content);
+}
+function extendAttributesTraitName(name) {
+    return `${toPascalCase(name)}ExtendAttributes`;
+}
 function generateForSchema(name, schema, reader, config) {
     const properties = (schema.properties ?? {});
     const options = schema.options ?? {};
@@ -104,9 +194,22 @@ function generateBaseModel(name, schema, reader, config) {
     const nestedSetParentColumn = null;
     const translatableFields = reader.getTranslatableFields(name);
     const hasTranslatable = translatableFields.length > 0;
-    const primaryKey = options['primaryKey'] ?? 'id';
+    // A schema may name its primary key three mutually-exclusive ways: the
+    // `id:` shortcut (always column "id"), `options.primaryKey` (composite),
+    // or a property carrying `primary: true` (custom-named single-column PK
+    // — omnify-go#167). The schema validator rejects any schema declaring
+    // more than one of these, so checking them in this order is safe.
+    const primaryKeyOption = options['primaryKey'];
+    const customPrimaryEntry = primaryKeyOption
+        ? undefined
+        : propertyOrder
+            .map((p) => [p, properties[p]])
+            .find(([, prop]) => prop?.['primary'] === true);
+    const primaryKey = primaryKeyOption ?? (customPrimaryEntry ? toSnakeCase(customPrimaryEntry[0]) : 'id');
     const rawId = options.id;
-    const idType = typeof rawId === 'string' ? rawId : 'BigInt';
+    const idType = customPrimaryEntry
+        ? (customPrimaryEntry[1]['type'] ?? 'String')
+        : (typeof rawId === 'string' ? rawId : 'BigInt');
     const isCompositeKey = primaryKey.includes(',');
     const needsUuidTrait = !isCompositeKey && idType === 'Uuid';
     const needsUlidTrait = !isCompositeKey && idType === 'Ulid';
@@ -168,6 +271,17 @@ function generateBaseModel(name, schema, reader, config) {
      */
     protected $keyType = 'string';
 
+    /**
+     * Indicates if the IDs are auto-incrementing.
+     */
+    public $incrementing = false;`;
+    }
+    else if (customPrimaryEntry && customPrimaryEntry[1]['autoIncrement'] !== true) {
+        // Integer-typed custom primary key not declared `autoIncrement: true`
+        // (omnify-go#167). Eloquent's Model default is $incrementing = true,
+        // which makes it omit the column on insert and read the value back via
+        // lastInsertId() — wrong for a key the caller assigns itself.
+        keyTypeSection = `
     /**
      * Indicates if the IDs are auto-incrementing.
      */
@@ -448,7 +562,11 @@ function buildDocProperties(properties, expandedProperties, propertyOrder, reade
         if (type === 'Association') {
             const relation = prop['relation'] ?? '';
             if (relation === 'ManyToOne') {
-                const snakeName = toFkColumnName(propName);
+                // omnify-go#166: honor the `column:` override (ForeignColumn) the
+                // migration generator already applies — falling back to the
+                // {property}_id convention here documents a column the table
+                // doesn't actually have.
+                const snakeName = prop['column'] || toFkColumnName(propName);
                 const nullable = prop['nullable'] ?? false;
                 const phpType = nullable ? 'int|null' : 'int';
                 lines.push(` * @property ${phpType} $${snakeName}`);
@@ -525,7 +643,8 @@ function buildFillable(properties, expandedProperties, propertyOrder) {
         if (type === 'Association') {
             const relation = prop['relation'] ?? '';
             if (relation === 'ManyToOne') {
-                fields.push(toFkColumnName(propName));
+                // omnify-go#166: honor the `column:` override (ForeignColumn).
+                fields.push(prop['column'] || toFkColumnName(propName));
             }
             else if (relation === 'MorphTo') {
                 const morphName = prop['morphName'] || toSnakeCase(propName);
@@ -633,7 +752,8 @@ function buildCasts(properties, expandedProperties, propertyOrder, reader, confi
                     ? targetSchema.options.id
                     : 'BigInt';
                 if (targetIdType !== 'Uuid' && targetIdType !== 'Ulid') {
-                    casts.push(`'${toFkColumnName(propName)}' => 'integer',`);
+                    // omnify-go#166: honor the `column:` override (ForeignColumn).
+                    casts.push(`'${prop['column'] || toFkColumnName(propName)}' => 'integer',`);
                 }
             }
             continue;
@@ -678,7 +798,9 @@ function buildCasts(properties, expandedProperties, propertyOrder, reader, confi
  *   4. Default — flat editable namespace (Laravel-canonical
  *      `App\Models\<Name>`).
  */
-function resolveRelatedModelNamespace(target, modelNamespace, config, reader) {
+function resolveRelatedModelNamespace(target, modelNamespace, config, reader, 
+/** The property's `targetNamespace`, for a target with no schema. */
+externalNamespace) {
     // Package schemas use their own model namespace (we don't generate
     // editable stubs for them — relations dispatch to the package class).
     const packageNs = reader.resolveModelNamespace(target, modelNamespace);
@@ -689,8 +811,16 @@ function resolveRelatedModelNamespace(target, modelNamespace, config, reader) {
         return config.models.namespace;
     }
     const targetSchema = reader.getSchema(target);
-    if (!targetSchema)
-        return config.models.userEditableNamespace;
+    if (!targetSchema) {
+        // A target outside the schema set is an external model, and
+        // `targetNamespace` is the documented way to say where it lives
+        // ("Target model namespace for external packages"). Ignoring it and
+        // falling back to this project's editable namespace emits
+        // `\App\Models\User` for a model that is not there — the relation
+        // resolves to a class that does not exist. The fallback still applies
+        // when the field is absent, which is every schema that does not use it.
+        return externalNamespace || config.models.userEditableNamespace;
+    }
     const editableNs = config.models.userEditableNamespace;
     if (targetSchema.kind === 'pivot') {
         return `${editableNs}\\Pivot`;
@@ -717,7 +847,9 @@ function buildRelations(schemaName, properties, propertyOrder, modelNamespace, r
         // Issue #98 v5.8.6: also nest by target's group / Pivot/ so the
         // FQCN matches the target file's actual location.
         const target = prop['target'] ?? '';
-        const ns = target ? resolveRelatedModelNamespace(target, modelNamespace, config, reader) : modelNamespace;
+        const ns = target
+            ? resolveRelatedModelNamespace(target, modelNamespace, config, reader, prop['targetNamespace'])
+            : modelNamespace;
         const targetTableName = target ? reader.getTableName(target) : '';
         // For ManyToMany, look up the explicit `kind: pivot` schema by pivotFor
         // pair (user-authored filenames may predate the sorted-name convention)
@@ -845,7 +977,11 @@ function buildInverseRelations(parentName, modelNamespace, reader, declaredMetho
             // generate a child-side accessor, not a parent-side one.
             // Here we're emitting the *parent* accessor, so the child's ManyToOne
             // (or owning OneToOne) is what we react to.
-            const fkColumn = toFkColumnName(childPropName);
+            // omnify-go#166: honor the child property's `column:` override
+            // (ForeignColumn) — the physical FK column lives on the child's
+            // table, so it must match whatever the child's own migration/model
+            // used, not the {property}_id convention.
+            const fkColumn = childProp['column'] || toFkColumnName(childPropName);
             // Issue #98 v5.8.6: nest the inverse-side FQCN by the CHILD's
             // group / Pivot/ so the relation resolves to the child's actual
             // file location (which lives in `<childGroup>/<Child>.php` or
@@ -890,16 +1026,28 @@ function buildAccessors(expandedProperties) {
     return methods.join('\n');
 }
 /** Generate a user model for a package schema that extends the package's model class. */
-function generatePackageUserModel(name, packageNamespace, config) {
+function generatePackageUserModel(name, packageNamespace, config, hasExtendAttributes = false) {
     const modelName = toPascalCase(name);
     const modelNamespace = config.models.namespace;
     const packageModelClass = `${packageNamespace}\\${modelName}`;
+    const traitName = extendAttributesTraitName(name);
+    // This file is created once and never rewritten, so the `use` line can only
+    // be put here for a model that does not exist yet. A project whose model
+    // predates its extend keeps the file it has, and `generateModels` warns with
+    // the one line to add — overwriting somebody's model to add an import is the
+    // worse of the two.
+    const traitImport = hasExtendAttributes
+        ? `use ${modelNamespace}\\Concerns\\${traitName};\n`
+        : '';
+    const traitUse = hasExtendAttributes
+        ? `    use ${traitName};\n\n`
+        : '';
     const content = `<?php
 
 namespace ${modelNamespace};
 
 use ${packageModelClass} as Package${modelName};
-
+${traitImport}
 /**
  * ${modelName} Model (extends package model)
  *
@@ -908,10 +1056,19 @@ use ${packageModelClass} as Package${modelName};
  */
 class ${modelName} extends Package${modelName}
 {
-    // Add your custom methods here
+${traitUse}    // Add your custom methods here
 }
 `;
-    return userFile(`${config.models.path}/${modelName}.php`, content);
+    return userFile(`${config.models.path}/${modelName}.php`, content, hasExtendAttributes
+        ? {
+            needle: `use ${traitName};`,
+            hint: `this project's \`kind: extend\` adds columns to the package-owned `
+                + `${modelName} schema, but this model predates the trait that carries `
+                + `them, so those columns are still not fillable or cast. Add `
+                + `\`use ${config.models.namespace}\\Concerns\\${traitName};\` and `
+                + `\`use ${traitName};\` inside the class (#164).`,
+        }
+        : undefined);
 }
 /**
  * Detect whether a schema uses nested set (tree structure).

package/dist/php/relation-builder.js

@@ -10,7 +10,7 @@ export function buildRelation(propName, property, modelNamespace, context) {
     let method = null;
     switch (relation) {
         case 'ManyToOne':
-            method = belongsTo(propName, target, modelNamespace);
+            method = belongsTo(propName, property, target, modelNamespace);
             break;
         case 'OneToOne':
             method = oneToOne(propName, property, target, modelNamespace);
@@ -60,8 +60,12 @@ export function getReturnType(relation) {
         default: return 'BelongsTo';
     }
 }
-function belongsTo(propName, target, ns) {
-    const foreignKey = toFkColumnName(propName);
+function belongsTo(propName, property, target, ns) {
+    // omnify-go#166: honor the `column:` override (ForeignColumn) — the
+    // migration generator already names the physical column from it, so
+    // falling back to the {property}_id convention here points the relation
+    // at a column the table doesn't have.
+    const foreignKey = property['column'] || toFkColumnName(propName);
     const methodName = toCamelCase(propName);
     const fqcn = `\\${ns}\\${target}`;
     return `    /**
@@ -86,7 +90,7 @@ function oneToOne(propName, property, target, ns) {
         return $this->hasOne(${fqcn}::class, '${foreignKey}');
     }`;
     }
-    return belongsTo(propName, target, ns);
+    return belongsTo(propName, property, target, ns);
 }
 function hasMany(propName, property, target, ns) {
     const inverse = property['mappedBy'] ?? property['inversedBy'] ?? null;

package/dist/php/resource-generator.js

@@ -18,13 +18,41 @@ import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace
 export function generateResources(reader, config) {
     const files = [];
     for (const [name, schema] of Object.entries(reader.getProjectVisibleObjectSchemas())) {
-        if (schema.kind === 'extend')
+        if (!generatesOwnResource(schema))
             continue;
         files.push(generateBaseResource(name, schema, reader, config));
         files.push(generateUserResource(name, schema, config));
     }
     return files;
 }
+/**
+ * Whether THIS generator writes a Resource for a project-owned schema.
+ *
+ * The loop above and the cross-resource reference below have to agree about
+ * this, and when they were two separate conditions they did not: the loop
+ * skipped `kind: extend`, and the reference did not ask at all — so a relation
+ * pointing at one named a class the loop had just declined to write.
+ */
+function generatesOwnResource(schema) {
+    return schema.kind !== 'extend' && schema.options?.hidden !== true;
+}
+/**
+ * Whether a Resource class exists for an association target — ours or a
+ * package's. `false` means there is no class to name, and the caller must fall
+ * back to a bare `whenLoaded()`.
+ */
+function hasResourceClass(target, reader) {
+    const schema = reader.getSchema(target);
+    // Not a schema at all: an external model reached through `targetNamespace`,
+    // e.g. the app's own User. Omnify generates nothing for it.
+    if (!schema)
+        return false;
+    // A package ships its own resources; whether they are reachable is the
+    // namespace question, which the caller answers separately.
+    if (schema.package != null)
+        return true;
+    return generatesOwnResource(schema);
+}
 function generateBaseResource(name, schema, reader, config) {
     const modelName = toPascalCase(name);
     // Issue #98 v5.8.2: nest namespace by group in legacy structure so the
@@ -242,8 +270,23 @@ function addAssociationFields(propName, prop, fields, resourceNamespace, modelNa
             targetResNs = editableNs;
         }
     }
-    // If target is a package schema without a resource namespace, use simple whenLoaded
-    if (!targetResNs && relation !== 'MorphTo') {
+    // The namespace resolving is not the same question as the class existing.
+    // `resolveResourceNamespace()` only returns null for a PACKAGE schema whose
+    // package declares no resource namespace — a target that is not a schema at
+    // all (an external model reached through `targetNamespace`, e.g. the app's
+    // own User), or one this generator declines to write a Resource for, falls
+    // through and is treated as project-owned. The reference then names
+    // `\<projectResourceNs>\<Target>Resource`, a class nothing declares, and
+    // `whenLoaded(..., fn () => new UserResource(...))` fatals the moment that
+    // relation is loaded and the resource is rendered.
+    //
+    // This is the same rule `interface-generator.ts` already applies on the TS
+    // side (`resolveTargetName` → `unknown` for a target outside the schema set),
+    // arriving late on the PHP side.
+    const targetHasResource = target ? hasResourceClass(target, reader) : false;
+    // If target is a package schema without a resource namespace, or a model no
+    // Resource is written for, use simple whenLoaded
+    if ((!targetResNs || !targetHasResource) && relation !== 'MorphTo') {
         if (relation === 'ManyToOne') {
             const snakeName = toFkColumnName(propName);
             fields.push(`            '${snakeName}' => $this->${snakeName},`);

package/dist/php/types.d.ts

@@ -7,11 +7,28 @@ export interface GeneratedFile {
     readonly content: string;
     readonly overwrite: boolean;
     readonly type: 'base' | 'user';
+    /**
+     * For a user file only: something the file has to contain that a version
+     * written by an EARLIER omnify would not have.
+     *
+     * A user file is created once and never rewritten, so a template that grows a
+     * new line reaches new projects and silently misses every existing one. The
+     * writer checks this against the file it skipped and prints `hint` when it is
+     * absent — telling the one project that needs the edit, rather than warning
+     * everybody on every run or overwriting somebody's code to add a line.
+     */
+    readonly expects?: {
+        readonly needle: string;
+        readonly hint: string;
+    };
 }
 /** Create a base file (always overwritten). */
 export declare function baseFile(path: string, content: string): GeneratedFile;
 /** Create a user file (created once, skip if exists). */
-export declare function userFile(path: string, content: string): GeneratedFile;
+export declare function userFile(path: string, content: string, expects?: {
+    needle: string;
+    hint: string;
+}): GeneratedFile;
 /** Category of base file for modular path resolution. */
 export type BaseCategory = 'Models' | 'Controllers' | 'Requests' | 'Resources' | 'Services' | 'Enums' | 'Traits' | 'Locales' | 'Policies';
 /**

package/dist/php/types.js

@@ -6,8 +6,8 @@ export function baseFile(path, content) {
     return { path, content, overwrite: true, type: 'base' };
 }
 /** Create a user file (created once, skip if exists). */
-export function userFile(path, content) {
-    return { path, content, overwrite: false, type: 'user' };
+export function userFile(path, content, expects) {
+    return { path, content, overwrite: false, type: 'user', ...(expects ? { expects } : {}) };
 }
 /**
  * Resolve base file path for a schema based on structure.

package/dist/types.d.ts

@@ -240,6 +240,14 @@ export interface SchemaDefinition {
     readonly properties?: Record<string, PropertyDefinition>;
     readonly propertyOrder?: readonly string[];
     readonly expandedProperties?: Record<string, ExpandedProperty>;
+    /**
+     * Properties a project-level `kind: extend` merged into this schema, in
+     * merge order. The Go loader folds an extend into its target and deletes
+     * the extend, so this is the only remaining trace of where they came from
+     * — which a PACKAGE-owned target needs, because the package's own generate
+     * run never saw them (#164).
+     */
+    readonly extendedProperties?: readonly string[];
     readonly values?: readonly EnumValueDefinition[];
     readonly pivotFor?: readonly string[];
     readonly policies?: readonly PolicyDefinition[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/ts",
-  "version": "6.0.6",
+  "version": "6.2.0",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",