@postxl/generators 0.2.2

package/dist/base/template/eslint.config.mjs

@@ -0,0 +1,194 @@
+// @ts-check
+
+import eslint from '@eslint/js'
+import reactConfigs from 'eslint-plugin-react'
+import reactHooks from 'eslint-plugin-react-hooks'
+import globals from 'globals'
+
+import simpleImportSort from 'eslint-plugin-simple-import-sort'
+import tseslint from 'typescript-eslint'
+
+// @ts-ignore
+const reactConfig = reactConfigs.configs.flat.recommended
+
+// tseslint.config() is a helper function that simply provides type safety for the ESLint flat config object.
+// Instead of an array of config objects, pass each object as an argument to tseslint.config()
+export default tseslint.config(
+  {
+    // Global ignore patterns
+    ignores: [
+      '**/dist/**/*',
+      '**/node_modules/**/*',
+      '**/tests/**/*',
+      'generators/**/template/**/*',
+      '**/coverage/**/*',
+      '**/dist/**/*',
+      '**/jest.config.ts',
+      '**/prettier.config.js',
+      'eslint.config.mjs',
+      '**/next.config.js',
+      '**/.next/**/*',
+      '**/test-results/*',
+      '**/playwright-report/*',
+      '**/playwright-report*',
+      '**/*.js',
+      // Ignore stories for now
+      '**/*.stories.tsx',
+    ],
+  },
+
+  // Default ESLint rules
+  eslint.configs.recommended,
+
+  // Recommended TypeScript rules
+  // TODO: Change to .strictTypeChecked
+  ...tseslint.configs.strict,
+  ...tseslint.configs.stylistic,
+
+  // Additional global settings
+  {
+    ignores: ['**/*.js'],
+
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    plugins: {
+      'simple-import-sort': simpleImportSort,
+    },
+    // Custom Rule Overrides and Settings
+    rules: {
+      // If we use "any", we typically do this on purpose
+      '@typescript-eslint/no-explicit-any': 'off',
+
+      // NestJS often defined empty classes but with decorators
+      '@typescript-eslint/no-extraneous-class': 'off',
+
+      // Ensure that promises are awaited
+      '@typescript-eslint/no-floating-promises': 'error',
+      '@typescript-eslint/require-await': 'error',
+
+      // We prefer `type` over `interface` for type definitions
+      '@typescript-eslint/consistent-type-definitions': ['error', 'type'],
+
+      // This rule is too strict and we use `!` to indicate that a value cannot be null
+      '@typescript-eslint/no-non-null-assertion': 'off',
+
+      // We want unused vars to be an error. However, vars named `_` are often used to indicate that a value is unused and are allowed.
+      'no-unused-vars': 'off',
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          args: 'all',
+          argsIgnorePattern: '^_',
+          caughtErrors: 'all',
+          caughtErrorsIgnorePattern: '^_',
+          destructuredArrayIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          ignoreRestSiblings: true,
+        },
+      ],
+
+      // This enforces that all template expressions are either number of string, other types must be stringified
+      '@typescript-eslint/restrict-template-expressions': [
+        'error',
+        {
+          allowNumber: true,
+          allowBoolean: true,
+        },
+      ],
+
+      // The "curly" rule ensures that all if, else if, else, for, while, or do blocks are followed by a block in braces, even if it is only a single line.
+      // This will flag `if(condition) return x` and expect it to be written as `if (condition) { return x }`
+      curly: ['error', 'all'],
+      'no-inner-declarations': 'off',
+
+      'padded-blocks': [
+        'error',
+        'never',
+        {
+          allowSingleLineBlocks: false,
+        },
+      ],
+
+      'simple-import-sort/imports': [
+        'error',
+        {
+          groups: [
+            // Node.js builtins. You could also generate this regex if you use a `.js` config
+            //  (e.g. `^(${require("module").builtinModules.join("|")})(/|$)`)
+            [
+              '^(assert|buffer|child_process|cluster|console|constants|crypto|dgram|dns|domain|events|fs|http|https|module|net|os|path|punycode|querystring|readline|repl|stream|string_decoder|sys|timers|tls|tty|url|util|vm|zlib|freelist|v8|process|async_hooks|http2|perf_hooks)(/.*|$)',
+            ],
+
+            // Side effect imports.
+            ['^\\u0000'],
+
+            // Any packages that starts with an @ but not libraries we defined in tsconfig.json:
+            ['^@(?!(postxl|assets|backend|hooks|components|i18n|lib|layout|theme|ui|public))'],
+
+            // Any other package.
+            ['^'],
+
+            // Internal PXL packages.
+            ['^(@postxl|@assets|@backend|@hooks|@components|@i18n|@lib|@layout|@theme|@ui|@public)(/.*|$)'],
+
+            // Parent imports. Put `..` last.
+            ['^\\.\\.(?!/?$)', '^\\.\\./?$'],
+
+            // Other relative imports. Put same-folder imports and `.` last.
+            ['^\\./(?=.*/)(?!/?$)', '^\\.(?!/?$)', '^\\./?$'],
+          ],
+        },
+      ],
+    },
+  },
+
+  // React-specific rules
+  // Source: https://www.npmjs.com/package/eslint-plugin-react
+  //
+  // Currently, eslint-config-next only support eslint v8.x.
+  // Until it is upgraded (and we upgraded to NextJS v15), we use the default
+  // react and react-hooks eslint plugins.
+  //
+  // @ts-ignore
+  {
+    settings: {
+      react: {
+        version: '18.3',
+      },
+    },
+    files: ['**/web/**/*.{ts,tsx,mtsx}', '**/frontend/**/*.{ts,tsx,mtsx}'],
+    ...reactConfig,
+    languageOptions: {
+      ...reactConfig.languageOptions,
+      globals: {
+        ...globals.serviceworker,
+        ...globals.browser,
+      },
+    },
+    rules: {
+      ...reactConfig.rules,
+      'react/prop-types': 'off',
+      'react/react-in-jsx-scope': 'off',
+    },
+  },
+  {
+    plugins: {
+      'react-hooks': reactHooks,
+    },
+    files: ['**/web/**/*.{ts,tsx,mtsx}', '**/frontend/**/*.{ts,tsx,mtsx}'],
+    rules: {
+      'react-hooks/rules-of-hooks': 'error',
+      'react-hooks/exhaustive-deps': 'error',
+    },
+  },
+
+  // Do not type check VFS files
+  {
+    files: ['**/vfs/**/*.ts', '**/vfs/**/*.tsx'],
+    extends: [tseslint.configs.disableTypeChecked],
+  },
+)

package/dist/base/template/jest.config.ts

@@ -0,0 +1,7 @@
+import type { Config } from 'jest'
+
+const config: Config = {
+  projects: ['<rootDir>/frontend', '<rootDir>/backend'],
+}
+
+export default config

package/dist/base/template/prettier.config.js

@@ -0,0 +1,10 @@
+// IMPORTANT: To ensure consistency between generated code and repo code,
+//            make sure that this file is kept in sync with
+//            `./packages/generator/src/utils/prettier-config.ts`!
+module.exports = {
+  semi: false,
+  trailingComma: 'all',
+  singleQuote: true,
+  tabWidth: 2,
+  printWidth: 120,
+}

package/dist/base/template/scripts/setup.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+# Install all packages
+echo "📦 Installing packages..."
+pnpm i
+
+# Copy the .env.example file to .env if it doesn't exist and replace the TURBO_TOKEN with the user's token
+if [[ ! -f .env ]]; then
+  echo "📝 Copying .env.example to .env..."
+  cp .env.example .env
+fi
+
+# Copy backend/apps/api/.env.example
+if [[ ! -f backend/apps/api/.env ]]; then
+  echo "📝 Copying backend/apps/api/.env.example to backend/apps/api/.env..."
+  cp backend/apps/api/.env.example backend/apps/api/.env
+fi
+
+# Copy frontend/.env.example
+if [[ ! -f frontend/.env ]]; then
+  echo "📝 Copying frontend/.env.example to frontend/.env..."
+  cp frontend/.env.example frontend/.env
+fi
+
+echo "🚀 Done!"

package/dist/base/template/sonar-project.properties

@@ -0,0 +1,94 @@
+sonar.projectKey=PostXL_template
+sonar.organization=postxl
+
+# This is the name and version displayed in the SonarCloud UI.
+#sonar.projectName=PXL
+#sonar.projectVersion=1.0
+
+
+# Path is relative to the sonar-project.properties file. Replace "\" by "/" on Windows.
+sonar.sources=backend,web
+
+# Encoding of the source code. Default is default system encoding
+#sonar.sourceEncoding=UTF-8
+
+# unit tests are excluded for now as they are not in sync with playwright tests
+sonar.javascript.lcov.reportPaths=\
+  # web/coverage/lcov.info, \
+  backend/coverage/lcov.info, \
+  backend/coverage/unit-tests/lcov.info, \
+  e2e/test-results/coverage/lcov.info, \
+  frontend/coverage/lcov.info 
+
+sonar.exclusions=\
+  **/node_modules/**, \
+  **/atoms/**, \
+  **/*.stories.tsx, \
+  **/import.service.js, **/import.service.ts, \
+  **/libs/xlport/**
+sonar.coverage.exclusions=\
+  **/node_modules/**, \
+  **/atoms/**, \
+  **/hooks/useCallbackWithEffect/**, \
+  **/hooks/useDelay/**, \
+  **/hooks/useWindowFocus/**, \
+  **/auth.controller.js, **/auth.controller.ts, \
+  **/auth.guard.js, **/auth.guard.ts, \
+  **/viewer.decorator.js, **/viewer.decorator.ts, \
+  **/auth.js, **/auth.ts, \
+  **/*.type.js, **/*.type.ts, \
+  **/*.types.js, **/*.types.ts, \
+  **/types.js, **/types.ts, \
+  **/libs/data/src/repositories/**, \
+  **/libs/export/src/**, \
+  **/import.service.js, **/import.service.ts, \
+  **/libs/s3/src/**, \
+  **/libs/update/src/**, \
+  **/libs/upload/src/**, \
+  **/libs/view/src/**, \
+  **/*.spec.ts, **/*.spec.js, \
+  **/*.test.js, **/*.test.ts
+sonar.cpd.exclusions=\
+  **/atoms/**, \
+  **/*.test.js, **/*.test.ts
+
+sonar.issue.ignore.multicriteria=e1,e3,e4,e5,e6a,e6b,e7
+
+# Ignore rule typescript:S2301 (https://sonarcloud.io/organizations/postxl/rules?open=typescript%3AS2301&rule_key=typescript%3AS2301)
+# The rule states that "Methods should not contain selector parameters", e.g.
+# `const  tempt = (name: string, ofAge: boolean) => ofAge ? offerLiquor(name) : offerCandy(name)`
+# This rule is ignored because it is a common pattern in our codebase and leads to many false positives.
+# For instance: `const isRequired = ({ isRequired }: Field): string => isRequired ? '' : '?'`
+sonar.issue.ignore.multicriteria.e1.ruleKey=typescript:S2301
+sonar.issue.ignore.multicriteria.e1.resourceKey=**/*.ts
+
+# Rule typescript:S6564 is "Redundant type aliases should not be used" -> https://sonarcloud.io/organizations/postxl/rules?open=typescript%3AS6564&rule_key=typescript%3AS6564
+# We often use type aliases to make the code more readable - and potentially replace with another implementation ('opaque types') in the future.
+sonar.issue.ignore.multicriteria.e3.ruleKey=typescript:S6564
+sonar.issue.ignore.multicriteria.e3.resourceKey=**/*.ts
+
+# Rule tsarchitecture:S7197 is "Circular file imports should be resolved" ->  https://sonarcloud.io/organizations/postxl/rules?open=tsarchitecture%3AS7197&rule_key=tsarchitecture%3AS7197
+# The backend has some circular dependencies that are unavoidable. We use NestJS forwardRef() to resolve circular dependencies.
+sonar.issue.ignore.multicriteria.e4.ruleKey=tsarchitecture:S7197
+sonar.issue.ignore.multicriteria.e4.resourceKey=backend/src/**/*.ts
+
+# Rule typescript:S63358 is "Ternary operators should not be nested" -> https://sonarcloud.io/organizations/postxl/rules?open=typescript%3AS3358&rule_key=typescript%3AS3358
+# In a lot of situation, an expression is cleaner (or in the case of TSX, required)  than an if/else statement. Using nested ternary operators, formatted
+# properly with Prettier is hence a more practical solution (and has similar readability).
+sonar.issue.ignore.multicriteria.e5.ruleKey=typescript:3358
+sonar.issue.ignore.multicriteria.e5.resourceKey=**/*.tsx
+
+# Rule typescript:S3735 is "void" should not be used" -> https://sonarcloud.io/organizations/postxl/rules?open=typescript%3AS3735&rule_key=typescript%3AS3735
+# We want to use 'void' to mark a promise as intentionally not awaited. This is a known exception to the general rule of avoiding 'void',
+# but still seen as an issue by SonarCloud.
+sonar.issue.ignore.multicriteria.e6a.ruleKey=typescript:S3735
+sonar.issue.ignore.multicriteria.e6a.resourceKey=frontend/**/*.tsx
+sonar.issue.ignore.multicriteria.e6b.ruleKey=typescript:S3735
+sonar.issue.ignore.multicriteria.e6b.resourceKey=frontend/**/*.ts
+
+
+# Rule typescript:S7738 is "Single-element arrays should not be passed to Promise methods" -> https://sonarcloud.io/organizations/postxl/rules?open=typescript%3AS7738&rule_key=typescript%3AS7738
+# This happens mainly in generated detect delta files - which we do not use.
+# // NOSONAR comments cannot be used there due to Prettier formatting.
+sonar.issue.ignore.multicriteria.e7.ruleKey=typescript:S7738
+sonar.issue.ignore.multicriteria.e7.resourceKey=backend/**/*.ts

package/dist/base/template/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "incremental": true,
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true
+  },
+  "exclude": ["node_modules"]
+}

package/dist/decoders/datamodel-decoder.generator.d.ts

@@ -0,0 +1,7 @@
+import { ContextResult } from './decoders.generator';
+/**
+ * Generates the data decoder, aggregating all the models.
+ */
+export declare function generateDataModelDecoder({ context: { decoders, models } }: {
+    context: ContextResult;
+}): string;

package/dist/decoders/datamodel-decoder.generator.js

@@ -0,0 +1,134 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDataModelDecoder = generateDataModelDecoder;
+const Generator = __importStar(require("@postxl/generator"));
+/**
+ * Generates the data decoder, aggregating all the models.
+ */
+function generateDataModelDecoder({ context: { decoders, models } }) {
+    const { dataModel, excelDataModel } = decoders;
+    const imports = Generator.ImportGenerator.from(dataModel.decoder.zodDecoder.location);
+    const encodedTypeEntries = [];
+    const decodedTypeEntries = [];
+    const encoderEntries = [];
+    const decoderEntries = [];
+    const encodedExcelTypeEntries = [];
+    const encoderExcelEntries = [];
+    const decoderExcelEntries = [];
+    const transformerExcelEntries = [];
+    for (const model of models.values()) {
+        imports.addType(model.decoder.flattened.encodedType);
+        encodedTypeEntries.push(`${model.decoder.dataModelEntry}: ${model.decoder.flattened.encodedType.name}[] | undefined`);
+        imports.addType(model.decoder.excel.encodedType);
+        encodedExcelTypeEntries.push(`${model.excelName}: ${model.decoder.excel.encodedType.name}[] | undefined`);
+        imports.addType(model.types);
+        decodedTypeEntries.push(`${model.decoder.dataModelEntry}?: ${model.types.name}[]`);
+        imports.add(model.decoder.flattened.encoder);
+        encoderEntries.push(`${model.decoder.dataModelEntry}: input.${model.decoder.dataModelEntry}?.map(${model.decoder.flattened.encoder.name}) ?? undefined`);
+        imports.add(model.decoder.excel.encoder);
+        encoderExcelEntries.push(`${model.excelName}: input.${model.decoder.dataModelEntry}?.map(${model.decoder.excel.encoder.name}) ?? undefined`);
+        imports.add(model.decoder.flattened.decoder.zodDecoder);
+        decoderEntries.push(`${model.decoder.dataModelEntry}: z.array(${model.decoder.flattened.decoder.zodDecoder.name}).optional()`);
+        imports.add(model.decoder.excel.decoder.zodDecoder);
+        decoderExcelEntries.push(`${model.excelName}: z.array(${model.decoder.excel.decoder.zodDecoder.name}).optional()`);
+        transformerExcelEntries.push(`${model.decoder.dataModelEntry}: v.${model.excelName} ?? []`);
+    }
+    return `
+import * as z from 'zod'
+${imports.generate()}
+
+/**
+ * All data from the data model exported as a flattened object
+ */
+export type ${dataModel.encodedType.name} = {
+  ${encodedTypeEntries.join(',\n')}
+}
+
+/**
+ * All data after decoding an imported flattened object
+ */
+export type ${dataModel.decodedType.name} = {
+  ${decodedTypeEntries.join(',\n')}
+}
+
+export function ${dataModel.encoder.name}(input: ${dataModel.decodedType.name}): ${dataModel.encodedType.name} {
+  return {
+    ${encoderEntries.join(',\n')}
+  }
+}
+
+/**
+ * Decoder that converts flattened model data to model data
+ */
+export const ${dataModel.decoder.zodDecoder.name} = z
+  .object({
+    ${decoderEntries.join(',\n')}
+  })
+
+export function ${dataModel.decoder.parseFunction.name}(input: ${dataModel.encodedType.name}): ${dataModel.decodedType.name} {
+  return ${dataModel.decoder.zodDecoder.name}.parse(input)
+}
+
+/**
+ * All data from the data model exported as a flattened Excel object
+ */
+export type ${excelDataModel.encodedType.name} = {
+  ${encodedExcelTypeEntries.join(',\n')}
+}
+
+export function ${excelDataModel.encoder.name}(input: ${dataModel.decodedType.name}): ${excelDataModel.encodedType.name} {
+  return {
+    ${encoderExcelEntries.join(',\n')}
+  }
+}
+
+/**
+ * Decoder that converts flattened Excel model data to model data
+ */
+export const ${excelDataModel.decoder.zodDecoder.name} = z
+  .object({
+    ${decoderExcelEntries.join(',\n')}
+  })
+  .transform((v) => ({
+    ${transformerExcelEntries.join(',\n')}
+  }))
+
+export function ${excelDataModel.decoder.parseFunction.name}(input: ${excelDataModel.encodedType.name}): ${dataModel.decodedType.name} {
+  return ${excelDataModel.decoder.zodDecoder.name}.parse(input)
+}
+`;
+}
+//# sourceMappingURL=datamodel-decoder.generator.js.map

package/dist/decoders/datamodel-decoder.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"datamodel-decoder.generator.js","sourceRoot":"","sources":["../../src/decoders/datamodel-decoder.generator.ts"],"names":[],"mappings":"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"}

package/dist/decoders/decoders.generator.d.ts

@@ -0,0 +1,133 @@
+import * as Generator from '@postxl/generator';
+import { FieldDiscriminatedUnion, FieldName } from '@postxl/schema';
+import { WithBackend } from '../backend-core';
+import { WithBase } from '../base';
+import { WithTypes } from '../types';
+export type ContextRequirements = WithTypes<WithBackend<WithBase<Generator.Context>>>;
+export type ContextResult = WithDecoders<ContextRequirements>;
+export type ModelContextRequirements = Generator.InferModelContext<ContextRequirements>;
+export type ModelResult = Generator.InferModelContext<ContextResult>;
+export type EnumContextRequirements = Generator.InferEnumContext<ContextRequirements>;
+export type EnumResult = Generator.InferEnumContext<ContextResult>;
+export type WithDecoders<Context> = Generator.ExtendContextAndModelAndEnum<Context, {
+    decoders: ContextDecoders;
+}, {
+    decoder: ModelContextDecoders;
+}, {
+    decoder: EnumContextDecoders;
+}>;
+export type ContextDecoders = {
+    /**
+     * Location of the decoders module (e.g. `@decoders`)
+     *
+     * Note: We do not provide a NestJS module for decoders - instead, all decoders are exposed directly as index.ts exports.
+     */
+    location: Generator.BackendModuleLocation;
+    /**
+     * The codec that encodes/decodes the data model to a flattened version
+     */
+    dataModel: CodecDefinition<DecoderWithoutTransformer>;
+    /**
+     * The codec that encodes/decodes the data model to a flattened version for Excel
+     */
+    excelDataModel: CodecDefinition<DecoderWithoutTransformer>;
+};
+export type ModelContextDecoders = DecoderDefinition<DecoderWithTransformer, DecoderWithTransformer> & {
+    discriminatedUnions: Map<FieldName, DiscriminatedUnionDecoderDefinition>;
+    /**
+     * Name of the data model property for the model
+     */
+    dataModelEntry: string;
+};
+export type DiscriminatedUnionDecoderDefinition = DecoderDefinition<DecoderWithoutTransformer, DecoderWithTransformer> & {
+    field: FieldDiscriminatedUnion;
+};
+export type EnumContextDecoders = {
+    /**
+     * The decoder that checks that the input is a valid enum
+     */
+    decoder: DecoderWithTransformer;
+    /**
+     * Function that encodes an enum. Currently this is returning the same value as the input.
+     */
+    encoder: Generator.ImportableFunction;
+};
+export type DecoderDefinition<DecoderType extends Decoder, FlattenedDecoderType extends Decoder> = {
+    /**
+     * The default decoder that checks that the input is a valid model
+     */
+    decoder: DecoderType;
+    /**
+     * Type, decoder and encoder for the flattened model. The flattened model is the model converted
+     * to a column structure (e.g. database, CSV), i.e. nested properties are flattened to a single level.
+     *
+     * Difference to the excel model is that the flattened version uses snake_case for the keys while Excel uses PascalCase.
+     */
+    flattened: CodecDefinition<FlattenedDecoderType>;
+    /**
+     * Type, decoder and encoder for the flattened Excel model. The flattened model is the model converted
+     * to a column structure for Excel, i.e. nested properties are flattened to a single level.
+     *
+     * Difference to the flattened model is that the Excel version uses PascalCase for the keys while the flattened version uses snake_case.
+     */
+    excel: CodecDefinition<FlattenedDecoderType>;
+};
+export type Decoder = DecoderWithoutTransformer | DecoderWithTransformer;
+type DecoderBase = {
+    /**
+     * The Zod decoder for the model
+     * Typically applies the rawInputValidation and the transformer
+     */
+    zodDecoder: Generator.ImportableConstant;
+    /**
+     * The decoder function that parses any input with the Zod decoder and returns a model
+     */
+    parseFunction: Generator.ImportableFunction;
+};
+type DecoderWithoutTransformer = DecoderBase & {
+    /**
+     * The discriminator
+     */
+    hasTransformer: false;
+};
+export type DecoderWithTransformer = DecoderBase & {
+    /**
+     * The discriminator
+     */
+    hasTransformer: true;
+    /**
+     * A Zod decoder that checks the raw input format and does simple type transformations, e.g. convert string to brands
+     */
+    rawInputValidation: Generator.ImportableConstant;
+    /**
+     * The intermediate type that is the result of the rawInputValidation and the input for the transformer
+     *
+     * We expose it as it can be useful when composing more complex decoders
+     */
+    rawInputType: Generator.ImportableType;
+    /**
+     * A Zod decoder that transforms the raw input to the model/discriminated union type
+     */
+    transformer: Generator.ImportableFunction;
+};
+export type CodecDefinition<DecoderType extends Decoder> = {
+    /**
+     * The type that is generated by the decoder and expected by the encoder
+     */
+    decodedType: Generator.ImportableType;
+    /**
+     * The type that is generated by the encoder and expected by the decoder
+     */
+    encodedType: Generator.ImportableType;
+    /**
+     * The decoder that decodes the codec type back to the original model
+     */
+    decoder: DecoderType;
+    /**
+     * The function that takes a model and encodes it to the codec type
+     */
+    encoder: Generator.ImportableFunction;
+};
+export declare const generatorId: string & import("zod").BRAND<"PXL.GeneratorInterfaceId">;
+export declare const generator: Generator.GeneratorInterface;
+export {};