@powerhousedao/codegen 5.0.0-staging.9 → 5.0.1-staging.10

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/ph-factories.esm.t

@@ -1,39 +1,36 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/ph-factories.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/ph-factories.ts"
 force: true
 ---
 /**
- * Factory methods for creating <%= h.changeCase.pascal(documentType) %>Document instances
+ * Factory methods for creating <%= phDocumentTypeName %> instances
  */
-
+import type {
+  PHAuthState,
+  PHDocumentState,
+  PHBaseState,
+} from "document-model";
 import {
   createBaseState,
   defaultBaseState,
-  type PHAuthState,
-  type PHDocumentState,
-  type PHBaseState,
-} from "document-model";
+} from "document-model/core";
 import type {
-  <%= h.changeCase.pascal(documentType) %>Document,
-  <%= h.changeCase.pascal(documentType) %>LocalState,
-  <%= h.changeCase.pascal(documentType) %>State,
+  <%= phDocumentTypeName %>,
+  <%= localStateName %>,
+  <%= globalStateName %>,
+  <%= phStateName %>,
 } from "./types.js";
 import { createDocument } from "./utils.js";
 
-export type <%= h.changeCase.pascal(documentType) %>PHState = PHBaseState & {
-  global: <%= h.changeCase.pascal(documentType) %>State;
-  local: <%= h.changeCase.pascal(documentType) %>LocalState;
-};
-
-export function defaultGlobalState(): <%= h.changeCase.pascal(documentType) %>State {
+export function defaultGlobalState(): <%= globalStateName %> {
   return <%- initialGlobalState %>;
 }
 
-export function defaultLocalState(): <%= h.changeCase.pascal(documentType) %>LocalState {
+export function defaultLocalState(): <%= localStateName %> {
   return <%- initialLocalState %>;
 }
 
-export function defaultPHState(): <%= h.changeCase.pascal(documentType) %>PHState {
+export function defaultPHState(): <%= phStateName %> {
   return {
     ...defaultBaseState(),
     global: defaultGlobalState(),
@@ -42,28 +39,28 @@ export function defaultPHState(): <%= h.changeCase.pascal(documentType) %>PHStat
 }
 
 export function createGlobalState(
-  state?: Partial<<%= h.changeCase.pascal(documentType) %>State>,
-): <%= h.changeCase.pascal(documentType) %>State {
+  state?: Partial<<%= globalStateName %>>,
+): <%= globalStateName %> {
   return {
     ...defaultGlobalState(),
     ...(state || {}),
-  } as <%= h.changeCase.pascal(documentType) %>State;
+  } as <%= globalStateName %>;
 }
 
 export function createLocalState(
-  state?: Partial<<%= h.changeCase.pascal(documentType) %>LocalState>,
-): <%= h.changeCase.pascal(documentType) %>LocalState {
+  state?: Partial<<%= localStateName %>>,
+): <%= localStateName %> {
   return {
     ...defaultLocalState(),
     ...(state || {}),
-  } as <%= h.changeCase.pascal(documentType) %>LocalState;
+  } as <%= localStateName %>;
 }
 
 export function createState(
   baseState?: Partial<PHBaseState>,
-  globalState?: Partial<<%= h.changeCase.pascal(documentType) %>State>,
-  localState?: Partial<<%= h.changeCase.pascal(documentType) %>LocalState>,
-): <%= h.changeCase.pascal(documentType) %>PHState {
+  globalState?: Partial<<%= globalStateName %>>,
+  localState?: Partial<<%= localStateName %>>,
+): <%= phStateName %> {
   return {
     ...createBaseState(baseState?.auth, baseState?.document),
     global: createGlobalState(globalState),
@@ -72,18 +69,18 @@ export function createState(
 }
 
 /**
- * Creates a <%= h.changeCase.pascal(documentType) %>Document with custom global and local state
+ * Creates a <%= phDocumentTypeName %> with custom global and local state
  * This properly handles the PHBaseState requirements while allowing
  * document-specific state to be set.
  */
-export function create<%= h.changeCase.pascal(documentType) %>Document(
+export function create<%= phDocumentTypeName %>(
   state?: Partial<{
     auth?: Partial<PHAuthState>;
     document?: Partial<PHDocumentState>;
-    global?: Partial<<%= h.changeCase.pascal(documentType) %>State>;
-    local?: Partial<<%= h.changeCase.pascal(documentType) %>LocalState>;
+    global?: Partial<<%= globalStateName %>>;
+    local?: Partial<<%= localStateName %>>;
   }>,
-): <%= h.changeCase.pascal(documentType) %>Document {
+): <%= phDocumentTypeName %> {
   const document = createDocument(
     state ? createState(
       createBaseState(state.auth, state.document),

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/reducer.esm.t

@@ -1,19 +1,27 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/reducer.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/reducer.ts"
 force: true
 ---
 // TODO: remove eslint-disable rules once refactor is done
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { type StateReducer, isDocumentAction, createReducer } from "document-model";
-import { <%= h.changeCase.pascal(documentType) %>PHState } from './ph-factories.js';
-import { z } from './types.js';
+import type { StateReducer } from "document-model";
+import { isDocumentAction, createReducer } from "document-model/core";
+import type { <%= phStateName %> } from "<%= documentModelDir %>";
 
-<% modules.forEach(m => { _%>
-import { reducer as <%= h.changeCase.pascal(m.name) %>Reducer } from '../src/reducers/<%= h.changeCase.param(m.name) %>.js';
+<% modules.forEach(module => { _%>
+import { <%= camelCaseDocumentType %><%= h.changeCase.pascal(module.name) %>Operations } from "../src/reducers/<%= h.changeCase.param(module.name) %>.js";
 <%_ }); %>
 
-export const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>PHState> =
+<% const schemas = modules.flatMap(m =>
+     m.operations.map(o => `${h.changeCase.pascalCase(o.name)}InputSchema`)
+   );
+%>
+import {
+  <%= schemas.join(',\n  ') %>
+} from "./schema/zod.js";
+
+const stateReducer: StateReducer<<%= phStateName %>> =
     (state, action, dispatch) => {
         if (isDocumentAction(action)) {
             return state;
@@ -24,9 +32,9 @@ export const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>
     modules.map(m => m.operations.map(o => 
         '            case "' + h.changeCase.constant(o.name) + '":\n' + 
         '                ' + (o.schema !== null ? 
-            'z.' + h.changeCase.pascalCase(o.name) + 'InputSchema().parse(action.input);\n' : 
+            h.changeCase.pascalCase(o.name) + 'InputSchema().parse(action.input);\n' : 
             'if (Object.keys(action.input).length > 0) throw new Error("Expected empty input for action ' + h.changeCase.constant(o.name) + '");\n') +
-        '                ' + h.changeCase.pascal(m.name) + 'Reducer.' + h.changeCase.camel(o.name) + 'Operation((state as any)[action.scope], action as any, dispatch);\n' +
+        '                ' + camelCaseDocumentType + h.changeCase.pascal(m.name)  + 'Operations.' + h.changeCase.camel(o.name) + 'Operation((state as any)[action.scope], action as any, dispatch);\n' +
         '                break;\n'        
     ).join('\n')).join('\n')
 %>
@@ -35,4 +43,4 @@ export const stateReducer: StateReducer<<%= h.changeCase.pascal(documentType) %>
         }
     }
 
-export const reducer = createReducer<<%= h.changeCase.pascal(documentType) %>PHState>(stateReducer);
+export const reducer = createReducer<<%= phStateName %>>(stateReducer);

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/root-utils.esm.t

@@ -0,0 +1,11 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/utils.ts"
+force: true
+---
+import type { DocumentModelUtils } from "document-model";
+import type { <%= phStateName %> } from "./gen/types.js";
+import { utils as genUtils } from "./gen/utils.js";
+import * as customUtils from "./src/utils.js";
+
+/** Utils for the <%= pascalCaseDocumentType %> document model */
+export const utils = { ...genUtils, ...customUtils } satisfies DocumentModelUtils<<%= phStateName %>>;

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/rootActions.esm.t

@@ -0,0 +1,13 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/actions.ts"
+force: true
+---
+import { baseActions } from "document-model";
+import { <% modules.forEach(module => { _%>
+<%= h.changeCase.camel(module.name) %>Actions,
+<% }); _%>  } from "./gen/creators.js";
+
+/** Actions for the <%= pascalCaseDocumentType %> document model */
+export const actions = { ...baseActions, <% modules.forEach(module => { _%>
+   ...<%= h.changeCase.camel(module.name) %>Actions,
+<% }); _%> };

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/rootIndex.esm.t

@@ -1,5 +1,5 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/index.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/index.ts"
 force: true
 ---
 /**
@@ -7,27 +7,8 @@ force: true
  * Delete the file and run the code generator again to have it reset
  */
 
-import { actions as BaseActions, type DocumentModelModule } from 'document-model';
-import { actions as <%= h.changeCase.pascal(documentType) %>Actions } from './gen/index.js';
-import { reducer } from './gen/reducer.js';
-import { documentModel } from './gen/document-model.js';
-import genUtils from './gen/utils.js';
-import * as customUtils from './src/utils.js';
-import type { <%= h.changeCase.pascal(documentType) %>PHState } from './gen/ph-factories.js';
-
-const utils = { ...genUtils, ...customUtils };
-const actions = { ...BaseActions, ...<%= h.changeCase.pascal(documentType) %>Actions };
-
-export const module: DocumentModelModule<
-    <%= h.changeCase.pascal(documentType) %>PHState
-> = {
-    reducer,
-    actions,
-    utils,
-    documentModel,
-};
-
-export { reducer, actions, utils, documentModel };
-
-export * from './gen/types.js';
-export * from './src/utils.js';
+export * from "./gen/index.js";
+export * from "./src/index.js";
+export * from "./hooks.js";
+export { actions } from "./actions.js";
+export { utils } from "./utils.js";

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/schema.esm.t

@@ -1,6 +1,6 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/schema/index.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/schema/index.ts"
 force: true
 ---
 export * from "./types.js";
-export * as z from "./zod.js";
+export * from "./zod.js";

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/src-index.esm.t

@@ -0,0 +1,5 @@
+---
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/src/index.ts"
+force: true
+---
+export * from "./utils.js";

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/types.esm.t

@@ -1,21 +1,31 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/types.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/types.ts"
 force: true
 ---
-import type { PHDocument } from 'document-model';
-import type { <%= h.changeCase.pascal(documentType) %>Action } from './actions.js';
-import type { <%= h.changeCase.pascal(documentType) %>PHState } from './ph-factories.js';
+import type { PHDocument, PHBaseState } from 'document-model';
+import type { <%= actionTypeName %> } from './actions.js';
 import type {
-  <%= h.changeCase.pascal(documentType) %>State,
+  <%= stateName %> as <%= globalStateName %>,
 <% if(hasLocalSchema) { -%>
-  <%= h.changeCase.pascal(documentType) %>LocalState,
+  <%= localStateName %>,
 <%} -%>
 } from './schema/types.js';
 
-export { z } from './schema/index.js';
-export type * from './schema/types.js';
 <% if(!hasLocalSchema) { -%>
-<%= 'type ' + h.changeCase.pascal(documentType) %>LocalState = Record<PropertyKey, never>;
+<%= 'type ' + localStateName %> = Record<PropertyKey, never>;
 <%} -%>
-export type <%= h.changeCase.pascal(documentType) %>Document = PHDocument<<%= h.changeCase.pascal(documentType) %>PHState>;
-export type { <%= h.changeCase.pascal(documentType) %>State, <%= h.changeCase.pascal(documentType) %>LocalState, <%= h.changeCase.pascal(documentType) %>Action };
+type <%= phStateName %> = PHBaseState & {
+  global: <%= globalStateName %>;
+  local: <%= localStateName %>;
+};
+type <%= phDocumentTypeName %> = PHDocument<<%= phStateName %>>;
+
+export * from './schema/types.js';
+
+export type { 
+  <%= globalStateName %>, 
+  <%= localStateName %>,
+  <%= phStateName %>, 
+  <%= actionTypeName %>,
+  <%= phDocumentTypeName %>,
+};

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model/utils.esm.t

@@ -1,70 +1,77 @@
 ---
-to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/utils.ts"
+to: "<%= rootDir %>/<%= paramCaseDocumentType %>/gen/utils.ts"
 force: true
 ---
+import type {
+    DocumentModelUtils,
+} from "document-model";
 import { 
-    type CreateDocument,
-    type CreateState,
-    type LoadFromFile,
-    type LoadFromInput,
     baseCreateDocument,
-    baseSaveToFile,
     baseSaveToFileHandle,
-    baseLoadFromFile,
     baseLoadFromInput,
     defaultBaseState,
     generateId,
- } from 'document-model';
-import { 
-  <%= 'type ' + h.changeCase.pascal(documentType) %>State,
-  <%= 'type ' + h.changeCase.pascal(documentType) %>LocalState
+ } from 'document-model/core';
+import type { 
+  <%= globalStateName %>,
+  <%= localStateName %>
 } from './types.js';
-import { <%= h.changeCase.pascal(documentType) %>PHState } from './ph-factories.js';
+import type { <%= phStateName %> } from './types.js';
 import { reducer } from './reducer.js';
+import { <%= documentTypeVariableName %> } from "./document-type.js";
+import {
+  <%= isPhDocumentOfTypeFunctionName %>,
+  <%= assertIsPhDocumentOfTypeFunctionName %>,
+  <%= isPhStateOfTypeFunctionName %>,
+  <%= assertIsPhStateOfTypeFunctionName %>,
+} from "./document-schema.js";
 
-export const initialGlobalState: <%= h.changeCase.pascal(documentType) %>State = <%- initialGlobalState %>;
-export const initialLocalState: <%= h.changeCase.pascal(documentType) %>LocalState = <%- initialLocalState %>;
-
-export const createState: CreateState<<%= h.changeCase.pascal(documentType) %>PHState> = (state) => {
-    return { 
-        ...defaultBaseState(), 
-        global: { ...initialGlobalState, ...(state?.global ?? {}) }, 
-        local: { ...initialLocalState, ...(state?.local ?? {}) } 
-    };
-};
-
-export const createDocument: CreateDocument<<%= h.changeCase.pascal(documentType) %>PHState> = (state) => {
-    const document = baseCreateDocument(createState, state);
-    document.header.documentType = '<%- documentTypeId %>';
-    // for backwards compatibility, but this is NOT a valid signed document id
-    document.header.id = generateId();
-    return document;
-};
-
-export const saveToFile = (document: any, path: string, name?: string) => {
-    return baseSaveToFile(document, path, '<%- fileExtension %>', name);
-};
+export const initialGlobalState: <%= globalStateName %> = <%- initialGlobalState %>;
+export const initialLocalState: <%= localStateName %> = <%- initialLocalState %>;
 
-export const saveToFileHandle = (document: any, input: any) => {
-    return baseSaveToFileHandle(document, input);
-};
+export const utils: DocumentModelUtils<<%= phStateName %>> = {
+    fileExtension: '<%- fileExtension %>',
+    createState(state) {
+        return { ...defaultBaseState(), global: { ...initialGlobalState, ...state?.global }, local: { ...initialLocalState, ...state?.local } };
+    },
+    createDocument(state) {
+        const document = baseCreateDocument(
+            utils.createState,
+            state
+        );
 
-export const loadFromFile: LoadFromFile<<%= h.changeCase.pascal(documentType) %>PHState> = (path) => {
-    return baseLoadFromFile(path, reducer);
-};
+        document.header.documentType = <%= documentTypeVariableName %>;
 
-export const loadFromInput: LoadFromInput<<%= h.changeCase.pascal(documentType) %>PHState> = (input) => {
-    return baseLoadFromInput(input, reducer);
-};
+        // for backwards compatibility, but this is NOT a valid signed document id
+        document.header.id = generateId();
 
-const utils = {
-    fileExtension: '<%- fileExtension %>',
-    createState,
-    createDocument,
-    saveToFile,
-    saveToFileHandle,
-    loadFromFile,
-    loadFromInput,
+        return document;
+    },
+    saveToFileHandle(document, input) {
+        return baseSaveToFileHandle(document, input);
+    },
+    loadFromInput(input) {
+        return baseLoadFromInput(input, reducer);
+    },
+    isStateOfType(state) {
+        return <%= isPhStateOfTypeFunctionName %>(state);
+    },
+    assertIsStateOfType(state) {
+        return <%= assertIsPhStateOfTypeFunctionName %>(state);
+    },
+    isDocumentOfType(document) {
+        return <%= isPhDocumentOfTypeFunctionName %>(document);
+    },
+    assertIsDocumentOfType(document) {
+        return <%= assertIsPhDocumentOfTypeFunctionName %>(document);
+    },
 };
 
-export default utils;
+export const createDocument = utils.createDocument;
+export const createState = utils.createState;
+export const saveToFileHandle = utils.saveToFileHandle;
+export const loadFromInput = utils.loadFromInput;
+export const isStateOfType = utils.isStateOfType;
+export const assertIsStateOfType = utils.assertIsStateOfType;
+export const isDocumentOfType = utils.isDocumentOfType;
+export const assertIsDocumentOfType = utils.assertIsDocumentOfType;

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model-module/creators.esm.t

@@ -2,15 +2,20 @@
 to: "<%= rootDir %>/<%= h.changeCase.param(documentType) %>/gen/<%= module %>/creators.ts"
 force: true
 ---
-import { createAction<% if (actions.find(a => a.hasAttachment)) {%>, AttachmentInput<%}%> } from 'document-model';
-import { z,
+import { createAction<% if (actions.find(a => a.hasAttachment)) {%>, AttachmentInput<%}%> } from 'document-model/core';
+import {
+<% actions.filter(a => a.hasInput).forEach(action => { _%>
+    <%= h.changeCase.pascal(action.name) %>InputSchema,
+<% }); _%>
+} from '../schema/zod.js';
+import type {
 <% actions.filter(a => a.hasInput).forEach(action => { _%>
-    <%= 'type ' + h.changeCase.pascal(action.name) %>Input,
+    <%= h.changeCase.pascal(action.name) %>Input,
 <% }); _%>
 } from '../types.js';
-import {
+import type {
 <% actions.forEach(action => { _%>
-    <%= 'type ' + h.changeCase.pascal(action.name) %>Action,
+    <%= h.changeCase.pascal(action.name) %>Action,
 <% }); _%>
 } from './actions.js';
 
@@ -20,7 +25,7 @@ export const <%= h.changeCase.camel(action.name) %> = (input: <%= h.changeCase.p
         '<%= h.changeCase.constantCase(action.name) %>',
         {...input},
         <%if(action.hasAttachment){ %>attachments<% } else { %>undefined<% } %>,
-        z.<%= h.changeCase.pascalCase(action.name) %>InputSchema,
+        <%= h.changeCase.pascalCase(action.name) %>InputSchema,
         '<%= action.scope %>'
     );
 

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model-module/customTest.esm.t

@@ -7,37 +7,32 @@ unless_exists: true
  * - change it by adding new tests or modifying the existing ones
  */
 
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import { generateMock } from '@powerhousedao/codegen';
-import utils from '../../gen/utils.js';
 import {
-    z,
-<% actions.forEach(action => { _%>
-    <%= 'type ' + h.changeCase.pascal(action.name) %>Input,
+  reducer,
+  utils,
+  <%= isPhDocumentOfTypeFunctionName %>,
+  <% actions.forEach(action => { _%>
+    <%= h.changeCase.camel(action.name) %>,
+    <%= h.changeCase.pascal(action.name) %>InputSchema,
 <% }); _%> 
-} from '../../gen/schema/index.js';
-import { reducer } from '../../gen/reducer.js';
-import * as creators from '../../gen/<%= module %>/creators.js';
-import type { <%= h.changeCase.pascal(documentType) %>Document } from '../../gen/types.js';
+} from "<%= documentModelDir %>";
 
 describe('<%= h.changeCase.pascal(module) %> Operations', () => {
-    let document: <%= h.changeCase.pascal(documentType) %>Document;
-
-    beforeEach(() => {
-        document = utils.createDocument();
-    });
-
 <% actions.forEach(action => { _%>
     it('should handle <%= h.changeCase.camel(action.name) %> operation', () => {
-        const input: <%= h.changeCase.pascal(action.name) %>Input = generateMock(
-            z.<%= h.changeCase.pascal(action.name) %>InputSchema(),
+        const document = utils.createDocument();
+        const input = generateMock(
+            <%= h.changeCase.pascal(action.name) %>InputSchema(),
         );
 
         const updatedDocument = reducer(
             document,
-            creators.<%= h.changeCase.camel(action.name) %>(input),
+            <%= h.changeCase.camel(action.name) %>(input),
         );
 
+        expect(<%= isPhDocumentOfTypeFunctionName %>(updatedDocument)).toBe(true);
         expect(updatedDocument.operations.<%= action.scope %>).toHaveLength(1);
         expect(updatedDocument.operations.<%= action.scope %>[0].action.type).toBe(
             '<%= h.changeCase.constant(action.name) %>',

package/dist/src/codegen/.hygen/templates/powerhouse/generate-document-model-module/index.js

@@ -1,40 +1,68 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const change_case_1 = require("change-case");
-exports.default = {
-    params: ({ args }) => {
-        const documentModel = JSON.parse(args.documentModel);
-        const latestSpec = documentModel.specifications[documentModel.specifications.length - 1];
-        const filteredModules = latestSpec.modules.filter((m) => m.name === args.module);
-        const actions = filteredModules.length > 0
-            ? filteredModules[0].operations.map((a) => ({
-                name: a.name,
-                hasInput: a.schema !== null,
-                hasAttachment: a.schema?.includes(": Attachment"),
-                scope: a.scope || "global",
-                state: a.scope === "global" ? "" : a.scope, // the state this action affects
-                errors: a.errors,
-            }))
-            : [];
-        const errors = actions.reduce((acc, action) => {
-            action.errors.forEach((error) => {
-                const existingError = acc.find((e) => e.code === error.code);
-                if (!existingError) {
-                    acc.push(error);
-                }
-                else if (JSON.stringify(existingError) !== JSON.stringify(error)) {
-                    console.warn(`Warning: Duplicate error code "${error.code}" with different fields found`);
-                }
-            });
-            return acc;
-        }, []);
-        return {
-            rootDir: args.rootDir,
-            documentType: documentModel.name,
-            module: (0, change_case_1.paramCase)(args.module),
-            actions,
-            errors,
-        };
-    },
+// @ts-check
+const { paramCase, pascalCase } = require("change-case");
+
+module.exports = {
+  params: ({ args }) => {
+    const documentModel = JSON.parse(args.documentModel);
+    const latestSpec =
+      documentModel.specifications[documentModel.specifications.length - 1];
+    const filteredModules = latestSpec.modules.filter(
+      (m) => m.name === args.module,
+    );
+
+    const actions =
+      filteredModules.length > 0
+        ? filteredModules[0].operations.map((a) => ({
+            name: a.name,
+            hasInput: a.schema !== null,
+            hasAttachment: a.schema?.includes(": Attachment"),
+            scope: a.scope || "global",
+            state: a.scope === "global" ? "" : a.scope, // the state this action affects
+            errors: a.errors,
+          }))
+        : [];
+
+    const errors = actions.reduce((acc, action) => {
+      action.errors.forEach((error) => {
+        // Fallback: If error code is empty, generate it from the error name in PascalCase
+        const errorCode = error.code || pascalCase(error.name || "");
+        const normalizedError = { ...error, code: errorCode };
+
+        const existingError = acc.find((e) => e.code === errorCode);
+        if (!existingError) {
+          acc.push(normalizedError);
+        } else if (
+          JSON.stringify(existingError) !== JSON.stringify(normalizedError)
+        ) {
+          console.warn(
+            `Warning: Duplicate error code "${errorCode}" with different fields found`,
+          );
+        }
+      });
+      return acc;
+    }, []);
+
+    const documentType = documentModel.name;
+    const pascalCaseDocumentType = pascalCase(documentType);
+    const phDocumentTypeName = `${pascalCaseDocumentType}Document`;
+    const isPhDocumentOfTypeFunctionName = `is${phDocumentTypeName}`;
+    const assertIsPhDocumentOfTypeFunctionName = `assertIs${phDocumentTypeName}`;
+    const paramCaseDocumentType = paramCase(documentType);
+    const packageName = args.packageName;
+    const documentModelDir = `${packageName}/document-models/${paramCaseDocumentType}`;
+    return {
+      rootDir: args.rootDir,
+      documentType: documentModel.name,
+      module: paramCase(args.module),
+      actions,
+      errors,
+      pascalCaseDocumentType,
+      paramCaseDocumentType,
+      packageName,
+      documentModelDir,
+      phDocumentTypeName,
+      isPhDocumentOfTypeFunctionName,
+      assertIsPhDocumentOfTypeFunctionName,
+    };
+  },
 };
-//# sourceMappingURL=index.js.map