type-crafter 0.9.2 → 0.9.3

package/dist/runtime.d.ts

@@ -0,0 +1,38 @@
+import type { AllOfTemplateInput, Configuration, EnumTemplateInput, ExporterModuleTemplateInput, GeneratedReferencedType, ObjectTemplateInput, OneOfTemplateInput, SpecFileData, TypeFilePath, TypesFileTemplateInput } from '$types';
+declare function setConfig(newConfig: Configuration): void;
+declare function getConfig(): Configuration;
+declare function setSpecFileData(newSpecFileData: SpecFileData): void;
+declare function getSpecFileData(): SpecFileData;
+declare function compileTemplates(): void;
+declare function getObjectTemplate(): HandlebarsTemplateDelegate<ObjectTemplateInput>;
+declare function getExporterModuleTemplate(): HandlebarsTemplateDelegate<ExporterModuleTemplateInput>;
+declare function getTypesFileTemplate(): HandlebarsTemplateDelegate<TypesFileTemplateInput>;
+declare function getEnumTemplate(): HandlebarsTemplateDelegate<EnumTemplateInput>;
+declare function getOneOfTemplate(): HandlebarsTemplateDelegate<OneOfTemplateInput>;
+declare function setExpectedOutputFiles(newExpectedOutputFiles: Map<string, TypeFilePath>): void;
+declare function getExpectedOutputFiles(): Map<string, TypeFilePath>;
+declare function getCachedReferencedTypes(): Map<string, GeneratedReferencedType>;
+declare function getCachedReferenceType(referencePath: string): GeneratedReferencedType | null;
+declare function cacheReferenceType(referencePath: string, generatedData: GeneratedReferencedType): void;
+declare function getInputFilePath(absolutePath?: boolean): string;
+declare function getAllOfTemplate(): HandlebarsTemplateDelegate<AllOfTemplateInput>;
+declare const _default: {
+    getConfig: typeof getConfig;
+    setConfig: typeof setConfig;
+    setSpecFileData: typeof setSpecFileData;
+    setExpectedOutputFiles: typeof setExpectedOutputFiles;
+    getSpecFileData: typeof getSpecFileData;
+    getObjectTemplate: typeof getObjectTemplate;
+    getExporterModuleTemplate: typeof getExporterModuleTemplate;
+    getTypesFileTemplate: typeof getTypesFileTemplate;
+    getEnumTemplate: typeof getEnumTemplate;
+    getExpectedOutputFiles: typeof getExpectedOutputFiles;
+    compileTemplates: typeof compileTemplates;
+    getOneOfTemplate: typeof getOneOfTemplate;
+    getCachedReferencedTypes: typeof getCachedReferencedTypes;
+    getCachedReferenceType: typeof getCachedReferenceType;
+    cacheReferenceType: typeof cacheReferenceType;
+    getInputFilePath: typeof getInputFilePath;
+    getAllOfTemplate: typeof getAllOfTemplate;
+};
+export default _default;

package/dist/templates/index.d.ts

@@ -0,0 +1,2 @@
+export * as typescript from './typescript';
+export * as typescriptWithDecoders from './typescript-with-decoders';

package/dist/templates/typescript/allOf-syntax.hbs

@@ -0,0 +1,19 @@
+export type {{typeName}} =
+  {{#each compositions}}
+  {{#if (eq this.source 'referenced')}}{{referencedType}}
+  {{else if (eq this.source 'inline')}}
+    {{#if this.templateInput.values}}
+      {{this.templateInput.typeName}}
+    {{else if (eq this.dataType 'object')}}
+      {{this.templateInput.typeName}}
+    {{else}}
+      {{this.templateInput.type}}
+    {{/if}}
+  {{/if}} {{#unless @last}} & {{/unless}}
+{{/each}};
+
+{{#each compositions}}
+{{#if (eq this.dataType 'object')}}
+{{{this.content}}}
+{{/if}}
+{{/each}}

package/dist/templates/typescript/enum-syntax.hbs

@@ -0,0 +1,13 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
+export type {{typeName}} =
+{{#each values}}
+  | {{#if (eq ../type 'string') }}'{{/if}}{{{this}}}{{#if (eq ../type 'string')}}'{{/if}}
+{{/each}};

package/dist/templates/typescript/exporter-module-syntax.hbs

@@ -0,0 +1,3 @@
+{{#each modules}}
+export * from './{{this}}';
+{{/each}}

package/dist/templates/typescript/index.d.ts

@@ -0,0 +1,2 @@
+import type { Configuration, TypesWriterMode, GroupedTypesWriterMode } from '$types';
+export declare function config(inputFilePath: string, outputDirectory: string, typesWriterMode: TypesWriterMode, groupedTypesWriterMode: GroupedTypesWriterMode): Promise<Configuration>;

package/dist/templates/typescript/object-syntax.hbs

@@ -0,0 +1,27 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
+export type {{typeName}} = {
+  {{#each properties}}
+  /**
+  {{#if this.description}}
+   * @description {{{this.description}}}
+  {{/if}}
+   * @type { {{this.type}} }
+   * @memberof {{../typeName}}
+  {{#if this.example}}
+   * @example {{{this.example}}}
+  {{/if}}
+   */
+  {{{jsonKey @key}}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
+  {{/each}}
+  {{#if additionalProperties}}
+  [keys: {{jsonKey additionalProperties.keyType}}]: {{additionalProperties.valueType}};
+  {{/if}}
+};

package/dist/templates/typescript/oneOf-syntax.hbs

@@ -0,0 +1,19 @@
+export type {{typeName}} =
+  {{#each compositions}}
+  | {{#if (eq this.source 'referenced')}}{{referencedType}}
+  {{else if (eq this.source 'inline')}}
+    {{#if this.templateInput.values}}
+      {{#each this.templateInput.values}}
+        {{#unless @first}}|{{/unless}} {{#if (eq ../this.templateInput.type 'string') }}'{{/if}}{{{this}}}{{#if (eq ../this.templateInput/type 'string')}}'{{/if}}
+      {{/each}}
+    {{else if (eq this.dataType 'object')}}
+      {
+        {{#each this.templateInput.properties}}
+        {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
+        {{/each}}
+      }
+    {{else}}
+      {{this.templateInput.type}}
+    {{/if}}
+  {{/if}}
+{{/each}};

package/dist/templates/typescript/types-file-syntax.hbs

@@ -0,0 +1,5 @@
+{{#each (getReferencedTypeModules referencedTypes writtenAt)}}
+import type { {{{this.referencedTypes}}} } from '{{this.moduleRelativePath}}';
+{{/each}}
+
+{{{typesContent}}}

package/dist/templates/typescript-with-decoders/allOf-syntax.hbs

@@ -0,0 +1,42 @@
+export type {{typeName}} =
+  {{#each compositions}}
+  {{#if (eq this.source 'referenced')}}{{referencedType}}
+  {{else if (eq this.source 'inline')}}
+    {{#if this.templateInput.values}}
+      {{this.templateInput.typeName}}
+    {{else if (eq this.dataType 'object')}}
+      {{this.templateInput.typeName}}
+    {{else}}
+      {{this.templateInput.type}}
+    {{/if}}
+  {{/if}} {{#unless @last}} & {{/unless}}
+{{/each}};
+
+{{#each compositions}}
+{{#if (eq this.dataType 'object')}}
+{{{this.content}}}
+{{/if}}
+{{/each}}
+
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
+  {{#each compositions}}
+  {{#if (eq this.source 'referenced')}}
+  const decoded{{referencedType}} = decode{{referencedType}}(rawInput);
+  {{else if (eq this.source 'inline')}}
+  const decoded{{toPascalCase this.templateInput.typeName}} = decode{{this.templateInput.typeName}}(rawInput);
+  {{/if}}
+  {{/each}}
+
+  if (
+    {{#each compositions}}decoded{{#if (eq this.source 'referenced')}}{{referencedType}}{{else}}{{toPascalCase this.templateInput.typeName}}{{/if}} !== null {{#unless @last}} && {{/unless}} {{/each}}
+    ) {
+      return {
+        {{#each compositions}}
+        {{#if (eq this.source 'referenced')}}...decoded{{referencedType}},
+        {{else}}...decoded{{toPascalCase this.templateInput.typeName}},
+        {{/if}}
+        {{/each}}
+      };
+    }
+  return null;
+}

package/dist/templates/typescript-with-decoders/enum-syntax.hbs

@@ -0,0 +1,33 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
+export type {{typeName}} =
+{{#each values}}
+  | {{#if (eq ../type 'string') }}'{{/if}}{{{this}}}{{#if (eq ../type 'string')}}'{{/if}}
+{{/each}};
+
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
+  switch (rawInput) {
+    {{#each values}}
+    case {{#if (eq ../type 'string') }}'{{/if}}{{this}}{{#if (eq ../type 'string')}}'{{/if}}:
+    {{/each}}
+     return rawInput;
+  }
+  return null;
+}
+
+export function _decode{{typeName}}(rawInput: unknown): {{typeName}} | undefined {
+  switch (rawInput) {
+    {{#each values}}
+    case {{#if (eq ../type 'string') }}'{{/if}}{{this}}{{#if (eq ../type 'string')}}'{{/if}}:
+    {{/each}}
+    return rawInput;
+  }
+  return;
+}

package/dist/templates/typescript-with-decoders/index.d.ts

@@ -0,0 +1,2 @@
+import type { Configuration, GroupedTypesWriterMode, TypesWriterMode } from '$types';
+export declare function config(inputFilePath: string, outputDirectory: string, typesWriterMode: TypesWriterMode, groupedTypesWriterMode: GroupedTypesWriterMode): Promise<Configuration>;

package/dist/templates/typescript-with-decoders/object-syntax.hbs

@@ -0,0 +1,73 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
+export type {{typeName}} = {{#if (not (isEmptyObject properties))}}{
+  {{#each properties}}
+  /**
+  {{#if this.description}}
+   * @description {{{this.description}}}
+  {{/if}}
+   * @type { {{this.type}} }
+   * @memberof {{../typeName}}
+  {{#if this.example}}
+   * @example {{{this.example}}}
+  {{/if}}
+  */
+  {{#if this.required}}
+  {{{jsonKey @key}}}: {{{this.type}}};
+  {{else if this.optional}}
+  {{{jsonKey @key}}}?: {{{this.type}}};
+  {{else}}
+  {{{jsonKey @key}}}: {{{this.type}}} | null;
+  {{/if}}
+  {{/each}}
+  {{#if additionalProperties}}
+  [keys: {{jsonKey additionalProperties.keyType}}]: {{additionalProperties.valueType}};
+  {{/if}}
+};
+{{else if (or (notEq length additionalProperties 0) (not (isEmptyObject additionalProperties)))}}
+Record<{{jsonKey additionalProperties.keyType}}, {{additionalProperties.valueType}}>;
+{{/if}}
+
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
+  if (isJSON(rawInput)) {
+    {{#each properties}}
+    const decoded{{variableName @key}} = {{#if this.referenced ~}}
+      decode{{{toPascalCase this.type}}}(rawInput[{{{indexKey @key}}}]);
+    {{~else~}}
+      {{~#if (eq this.primitiveType 'array')~}} 
+      decodeArray(rawInput[{{{indexKey @key}}}], decode{{{toPascalCase this.composerType}}})
+      {{~else~}}
+       {{#if this.optional}}_{{/if}}decode{{{toPascalCase this.type}}}(rawInput[{{{indexKey @key}}}])
+      {{~/if~}};
+    {{~/if}}
+
+    {{/each}}
+
+    {{#if (areRequiredKeysPresent properties)}}
+    if (
+      {{#each (getRequiredKeys properties)}}
+      decoded{{toPascalCase this}} === null{{#unless @last}} ||{{/unless}}
+      {{/each}}
+    ) {
+      return null;
+    }
+    {{/if}}
+
+    return {
+      {{#if additionalProperties}}
+      ...rawInput,
+      {{/if}}
+      {{#each properties}}
+      {{{jsonKey @key}}}: decoded{{{variableName @key}}}{{#unless @last}},{{/unless}}
+      {{/each}}
+    };
+  }
+  return null;
+}

package/dist/templates/typescript-with-decoders/oneOf-syntax.hbs

@@ -0,0 +1,74 @@
+export type {{typeName}} =
+  {{#each compositions}}
+  | {{#if (eq this.source 'referenced')}}C{{../typeName}}{{referencedType}}
+  {{else if (eq this.source 'inline')}}
+    {{#if this.templateInput.values}}
+      {{this.templateInput.typeName}}
+    {{else if (eq this.dataType 'object')}}
+      C{{typeName}}{{this.templateInput.typeName}}
+    {{else}}
+      {{this.templateInput.type}}
+    {{/if}}
+  {{/if}}
+{{/each}};
+
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
+  const result: {{typeName}} | null =
+  {{#each compositions}}
+  {{#if (eq this.source 'referenced')}}
+    decodeC{{../typeName}}{{referencedType}}(rawInput)
+  {{else if (eq this.dataType 'object')}}
+    decodeC{{this.templateInput.typeName}}(rawInput)
+  {{else if (eq this.dataType 'array')}}
+    decodeArray(rawInput, decode{{{toPascalCase this.templateInput.composerType}}})
+  {{else if this.templateInput.values}}
+    decode{{this.templateInput.typeName}}(rawInput)
+  {{else}}
+    decode{{{toPascalCase this.templateInput.type}}}(rawInput)
+  {{/if}}{{#unless @last}}??{{/unless}}
+  {{/each}};
+  return result;
+}
+
+
+{{#each compositions}}
+
+{{#if this.templateInput.values}}
+{{{this.content}}}
+{{else if (eq this.source 'referenced')}}
+export class C{{../typeName}}{{referencedType}} {
+  data: {{referencedType}};
+  constructor(data: {{referencedType}}) {
+    this.data = data;
+  }
+}
+
+export function decodeC{{../typeName}}{{referencedType}}(rawInput: unknown): C{{../typeName}}{{referencedType}} | null {
+  const result = decode{{referencedType}}(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new C{{../typeName}}{{referencedType}}(result);
+}
+
+{{else if (eq this.dataType 'object')}}
+
+{{{this.content}}}
+
+export class C{{../typeName}}{{this.templateInput.typeName}} {
+  data: {{this.templateInput.typeName}};
+  constructor(data: {{this.templateInput.typeName}}) {
+    this.data = data;
+  }
+}
+
+export function decodeC{{this.templateInput.typeName}}(rawInput: unknown) {
+  const result = decode{{this.templateInput.typeName}}(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new C{{../typeName}}{{this.templateInput.typeName}}(result);
+}
+
+{{/if}}
+{{/each}}

package/dist/templates/typescript-with-decoders/types-file-syntax.hbs

@@ -0,0 +1,7 @@
+{{#each (getReferencedTypeModules referencedTypes writtenAt)}}
+import { {{#each this.referencedTypes}}type {{this}}, decode{{this}}{{#unless @last}}, {{/unless}} {{/each}} } from '{{this.moduleRelativePath}}';
+{{/each}}
+import { isJSON, {{#each primitives}}decode{{{toPascalCase this}}}, _decode{{{toPascalCase this}}} {{#unless @last}}, {{/unless}}{{/each}} } from 'type-decoder';
+
+{{{typesContent}}}
+

package/dist/types/decoders.d.ts

@@ -0,0 +1,12 @@
+import type { GroupRef, EnumTemplateInput, GroupedTypesWriterMode, ObjectTemplateInputProperties, SpecFileData, TypeInfo, Types, TypesWriterMode, GroupTypesData, KeyedAdditionalProperties, AdditionalPropertiesKeyType } from '.';
+export declare function decodeGroupedTypesWriterMode(rawInput: unknown): GroupedTypesWriterMode | null;
+export declare function decodeTypesWriterMode(rawInput: unknown): TypesWriterMode | null;
+export declare function decodeSpecFileData(rawInput: unknown): SpecFileData | null;
+export declare function valueIsGroupRef(value: GroupTypesData): value is GroupRef;
+export declare function decodeTypes(rawInput: unknown): Types | null;
+export declare function decodeAdditionalPropertiesKeyType(rawInput: unknown): AdditionalPropertiesKeyType | null;
+export declare function decodeTypeInfo(rawInput: unknown): TypeInfo | null;
+export declare function valueIsKeyedAdditionalProperties(value: unknown): value is KeyedAdditionalProperties;
+export declare function valueIsTypeInfo(value: unknown): value is TypeInfo;
+export declare function decodeObjectTemplateInputProperties(rawInput: unknown): ObjectTemplateInputProperties | null;
+export declare function decodeEnumTemplateInput(rawInput: unknown): EnumTemplateInput | null;

package/dist/types/index.d.ts

@@ -0,0 +1,185 @@
+export * from './decoders';
+export type Configuration = {
+    input: string;
+    output: OutputConfig;
+    template: Template;
+    language: LanguageConfig;
+};
+export type OutputConfig = {
+    cleanWrite: boolean;
+    fileExtension: string;
+    directory: string;
+    writerMode: {
+        groupedTypes: GroupedTypesWriterMode;
+        types: TypesWriterMode;
+    };
+};
+export type GroupedTypesWriterMode = 'FolderWithFiles' | 'SingleFile';
+export type TypesWriterMode = 'SingleFile' | 'Files';
+export type Template = {
+    objectSyntax: string;
+    exporterModuleSyntax: string;
+    typesFileSyntax: string;
+    enumSyntax: string;
+    oneOfSyntax: string;
+    allOfSyntax: string;
+};
+export type LanguageConfig = {
+    exporterModuleName: string;
+    typeMapper: LanguageTypeMapper;
+};
+/**
+ * @description Mappers for all the types supported by OpenAPI 3.0.0
+ * @see https://swagger.io/docs/specification/data-models/data-types/
+ */
+export type LanguageTypeMapper = Record<TypeDataType, FormatType | string>;
+export type FormatType = {
+    default: string;
+    [format: string]: string | undefined;
+};
+export type ReferenceType = 'local' | 'remote' | 'url';
+export type ReferenceMeta = {
+    completeSource: string;
+    sourceFile: string;
+    path: string;
+    type: ReferenceType;
+    name: string;
+};
+export type ResolvedTypeReferenceData = ReferenceMeta & {
+    typeInfo: TypeInfo;
+};
+export type ResolvedGroupReferenceData = ReferenceMeta & {
+    groupedTypes: Types;
+};
+export type GeneratedReferencedType = ResolvedTypeReferenceData & {
+    templateData: GeneratedType<TemplateInput>;
+};
+export type SpecFileData = {
+    info: SpecInfo;
+    groupedTypes: GroupedTypes | null;
+    types: Types | null;
+};
+export type SpecInfo = {
+    version: string;
+    title: string;
+};
+type GroupName = string;
+export type GroupedTypes = Record<GroupName, GroupTypesData>;
+export type GroupTypesData = Types | GroupRef;
+export type GroupRef = {
+    $ref: string;
+};
+type TypeName = string;
+export type Types = Record<TypeName, TypeInfo>;
+export type TypeInfo = TypeDescriptors & {
+    required: string[] | null;
+    optional: string[] | null;
+    type: TypeDataType | null;
+    format: string | null;
+    items: TypeInfo | null;
+    properties: TypeProperties | null;
+    $ref: string | null;
+    oneOf: TypeInfo[] | null;
+    allOf: TypeInfo[] | null;
+    enum: string[] | number[] | null;
+    additionalProperties: AdditionalProperties | null;
+};
+export type AdditionalProperties = KeyedAdditionalProperties | TypeInfo | boolean;
+export type KeyedAdditionalProperties = {
+    keyType: AdditionalPropertiesKeyType;
+    valueType: TypeInfo;
+};
+export type AdditionalPropertiesKeyType = 'string' | 'number';
+type PropertyName = string;
+export type TypeProperties = Record<PropertyName, TypeInfo>;
+export type TypeDataType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'unknown';
+export type TypeDescriptors = {
+    summary: string | null;
+    example: string | number | null;
+    description: string | null;
+};
+export type ObjectTemplateInput = TypeDescriptors & {
+    typeName: string;
+    type: string;
+    properties: ObjectTemplateInputProperties;
+    additionalProperties?: AdditionalPropertiesTemplateInput;
+};
+export type ObjectTemplateInputProperties = Record<PropertyName, ObjectTemplateInputProperty>;
+export type ObjectTemplateInputProperty = TypeDescriptors & {
+    type: string;
+    required: boolean;
+    referenced: boolean;
+    primitiveType: string;
+    composerType: string | null;
+    optional: boolean;
+};
+export type AdditionalPropertiesTemplateInput = {
+    keyType: string;
+    valueType: string;
+};
+export type ExporterModuleTemplateInput = {
+    modules: string[];
+};
+export type TypesFileTemplateInput = {
+    referencedTypes: string[];
+    primitives: string[];
+    typesContent: string;
+    writtenAt: string;
+};
+export type ReferencedModule = {
+    modulePath: string;
+    moduleRelativePath: string;
+    referencedTypes: string[];
+};
+export type EnumTemplateInput = TypeDescriptors & {
+    typeName: string;
+    type: string;
+    values: string[] | number[];
+};
+export type OneOfTemplateInput = TypeDescriptors & {
+    typeName: string;
+    type: string;
+    compositions: OneOfTemplateInputComposition[];
+};
+export type OneOfTemplateInputComposition = {
+    dataType?: TypeDataType | null;
+    templateInput?: TemplateInput;
+    source: 'inline' | 'referenced';
+    referencedType?: string;
+    content?: string;
+};
+export type AllOfTemplateInput = TypeDescriptors & {
+    typeName: string;
+    type: string;
+    compositions: AllOfTemplateInputComposition[];
+};
+export type AllOfTemplateInputComposition = {
+    dataType?: TypeDataType | null;
+    templateInput?: TemplateInput;
+    source: 'inline' | 'referenced';
+    referencedType?: string;
+    content?: string;
+};
+export type VariableTemplateInput = TypeDescriptors & {
+    typeName: string;
+    type: string;
+    composerType?: string;
+};
+export type TemplateInput = ObjectTemplateInput | EnumTemplateInput | OneOfTemplateInput | AllOfTemplateInput | VariableTemplateInput;
+export type GenerationResult = {
+    groupedTypes: GroupedTypesOutput;
+    types: GeneratedTypes;
+};
+export type GeneratedType<TemplateType extends TemplateInput> = {
+    content: string;
+    references: Set<string>;
+    primitives: Set<string>;
+    templateInput: TemplateType;
+};
+export type GroupedTypesOutput = Record<GroupName, GeneratedTypes>;
+export type GeneratedTypes = Record<TypeName, GeneratedType<TemplateInput>>;
+export type TypeFilePath = {
+    modulePath: string;
+    filePath: string;
+    extension: string;
+};

package/dist/utils/error-handler.d.ts

@@ -0,0 +1,16 @@
+export declare class LanguageNotSupportedError extends Error {
+    constructor(language: string);
+}
+export declare class InvalidParamError extends Error {
+    constructor(key: string, value: string);
+}
+export declare class InvalidSpecFileError extends Error {
+    constructor(param: string);
+}
+export declare class RuntimeError extends Error {
+    constructor(message: string);
+}
+export declare class UnsupportedFeatureError extends Error {
+    constructor(message: string);
+}
+export declare function handleErrors(error: unknown): void;

package/dist/utils/file-system.d.ts

@@ -0,0 +1,9 @@
+export declare function resolveFilePath(filePath: string, useCurrentDirectory?: boolean): string;
+export declare function readFile(filePath: string, useCurrentWorkingDirectory?: boolean, caseSensitive?: boolean): Promise<string>;
+export declare function createFolderWithBasePath(basePath: string, folderName: string): Promise<void>;
+export declare function createFolder(folderPath: string): Promise<void>;
+export declare function deleteFolder(folderPath: string): Promise<void>;
+export declare function getCompleteFolderPath(folderName: string): Promise<string>;
+export declare function getExpectedWrittenPath(basePath: string, fileName: string): Promise<string>;
+export declare function writeFile(basePath: string, fileName: string, content: string): Promise<void>;
+export declare function readYaml(filePath: string): Promise<unknown>;

package/dist/utils/index.d.ts

@@ -0,0 +1,17 @@
+import { type JSONObject } from 'type-decoder';
+export * from './file-system';
+export * from './logger';
+export declare function addValuesToMappedSet(map: Map<string, Set<string>>, key: string, values: string[]): void;
+export declare function getOptionalKeys(object: unknown): string[];
+export declare function getRequiredKeys(object: unknown): string[];
+export declare function getReferencedTypes(object: unknown): string[];
+export declare function getReferencedTypeModules(_referencedTypes: unknown, _writtenAt: string): unknown[];
+export declare function toPascalCase(input: string): string;
+export declare function toPascalCaseHelper(input: unknown): string | unknown;
+export declare function refineJSONKey(input: unknown): unknown;
+export declare function refineVariableName(input: unknown): unknown;
+export declare function refineIndexKey(input: unknown): unknown;
+export declare function registerTemplateHelpers(): void;
+export declare function readNestedValue(json: unknown, keyPath: string[]): JSONObject;
+export declare function generateRelativePath(fromPath: string, toPath: string): string;
+export declare function stripPrefix(value: string, prefix: string): string;

package/dist/utils/logger.d.ts

@@ -0,0 +1,4 @@
+export declare function logError(header: string, message?: string | null): void;
+export declare function logWarning(header: string, message: string): void;
+export declare function logSuccess(header: string, message: string): void;
+export declare function greeting(): void;

package/dist/writer/helpers.d.ts

@@ -0,0 +1,3 @@
+import { type TypeFilePath, type Types } from '$types';
+export declare function generateTypesOutputFiles(types: Types | null, groupName?: string | null): Map<string, TypeFilePath>;
+export declare function generateExpectedOutputFile(): Map<string, TypeFilePath>;

package/dist/writer/index.d.ts

@@ -0,0 +1,2 @@
+import type { GenerationResult } from '$types';
+export declare function writeOutput(generationResult: GenerationResult): Promise<void>;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "type-crafter",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "A tool to generate types from a yaml schema for any language",
   "main": "./dist/index.js",
   "type": "module",
   "bin": {
-    "type-crafter": "dist/index.js"
+    "type-crafter": "./dist/index.js"
   },
   "files": [
     "dist",