@kubb/plugin-msw 4.1.4 → 4.2.1

package/dist/{types-DLxzBV0T.d.cts → types-BLiYk9M7.d.ts}

@@ -1,10 +1,11 @@
-import { HttpMethod, OasTypes, Operation as Operation$1, SchemaObject as SchemaObject$1, contentType } from "./types-DYAniEBx.cjs";
+import { a as contentType, i as SchemaObject$1, n as OasTypes, r as Operation$1, t as HttpMethod } from "./types-IbHKcY02.js";
 import { OASDocument, SchemaObject, User } from "oas/types";
 import { Operation } from "oas/operation";
 import { OpenAPIV3 } from "openapi-types";
 import * as oas_normalize_lib_types0 from "oas-normalize/lib/types";
 import BaseOas from "oas";
 import { ConsolaInstance, LogLevel } from "consola";
+import { FileManager } from "@kubb/fabric-core";
 
 //#region ../oas/src/Oas.d.ts
 type Options$3 = {
@@ -39,17 +40,17 @@ declare class Oas<const TOAS = unknown> extends BaseOas {
  * Abstract class that contains the building blocks for plugins to create their own Generator
  * @link idea based on https://github.com/colinhacks/zod/blob/master/src/types.ts#L137
  */
-declare abstract class BaseGenerator<TOptions = unknown, TContext = unknown> {
+declare abstract class BaseGenerator<TOptions$1 = unknown, TContext = unknown> {
   #private;
-  constructor(options?: TOptions, context?: TContext);
-  get options(): TOptions;
+  constructor(options?: TOptions$1, context?: TContext);
+  get options(): TOptions$1;
   get context(): TContext;
-  set options(options: TOptions);
+  set options(options: TOptions$1);
   abstract build(...params: unknown[]): unknown;
 }
 //#endregion
 //#region ../core/src/fs/types.d.ts
-type BasePath<T extends string = string> = `${T}/`;
+type BasePath<T$1 extends string = string> = `${T$1}/`;
 type Import = {
   /**
    * Import name to be used
@@ -123,7 +124,7 @@ type BaseName = `${string}.${string}`;
  * Path will be full qualified path to a specified file
  */
 type Path = string;
-type AdvancedPath<T extends BaseName = BaseName> = `${BasePath}${T}`;
+type AdvancedPath<T$1 extends BaseName = BaseName> = `${BasePath}${T$1}`;
 type OptionalPath = Path | undefined | null;
 type File<TMeta extends object = object> = {
   /**
@@ -212,9 +213,7 @@ type Logger = {
 };
 //#endregion
 //#region ../core/src/utils/types.d.ts
-type PossiblePromise<T> = Promise<T> | T;
-type ArrayWithLength<T extends number, U extends any[] = []> = U['length'] extends T ? U : ArrayWithLength<T, [true, ...U]>;
-type GreaterThan<T extends number, U extends number> = ArrayWithLength<U> extends [...ArrayWithLength<T>, ...infer _] ? false : true;
+type PossiblePromise<T$1> = Promise<T$1> | T$1;
 //#endregion
 //#region ../core/src/types.d.ts
 type InputPath = {
@@ -327,11 +326,11 @@ TName extends string = string,
 /**
  * Options of the plugin.
  */
-TOptions extends object = object,
+TOptions$1 extends object = object,
 /**
  * Options of the plugin that can be used later on, see `options` inside your plugin config.
  */
-TResolvedOptions extends object = TOptions,
+TResolvedOptions extends object = TOptions$1,
 /**
  * Context that you want to expose to other plugins.
  */
@@ -345,23 +344,23 @@ TResolvePathOptions extends object = object> = {
    * Same behaviour like what has been done with `QueryKey` in `@tanstack/react-query`
    */
   key: PluginKey<TName | string>;
-  options: TOptions;
+  options: TOptions$1;
   resolvedOptions: TResolvedOptions;
   context: TContext;
   resolvePathOptions: TResolvePathOptions;
 };
 type PluginKey<TName> = [name: TName, identifier?: string | number];
-type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+type UserPlugin<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name used for the plugin
    * The name of the plugin follows the format scope:foo-bar or foo-bar, adding scope: can avoid naming conflicts with other plugins.
    * @example @kubb/typescript
    */
-  name: TOptions['name'];
+  name: TOptions$1['name'];
   /**
    * Options set for a specific plugin(see kubb.config.js), passthrough of options.
    */
-  options: TOptions['resolvedOptions'];
+  options: TOptions$1['resolvedOptions'];
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
    * Can be used to validate dependent plugins.
@@ -371,23 +370,23 @@ type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
    * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
    */
   post?: Array<string>;
-} & (TOptions['context'] extends never ? {
+} & (TOptions$1['context'] extends never ? {
   context?: never;
 } : {
-  context: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['context'];
+  context: (this: TOptions$1['name'] extends 'core' ? null : Omit<PluginContext<TOptions$1>, 'addFile'>) => TOptions$1['context'];
 });
-type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>;
-type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+type UserPluginWithLifeCycle<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions$1> & PluginLifecycle<TOptions$1>;
+type Plugin<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name used for the plugin
    * @example @kubb/typescript
    */
-  name: TOptions['name'];
+  name: TOptions$1['name'];
   /**
    * Internal key used when a developer uses more than one of the same plugin
    * @private
    */
-  key: TOptions['key'];
+  key: TOptions$1['key'];
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
    * Can be used to validate dependent plugins.
@@ -400,49 +399,49 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Options set for a specific plugin(see kubb.config.js), passthrough of options.
    */
-  options: TOptions['resolvedOptions'];
-} & (TOptions['context'] extends never ? {
+  options: TOptions$1['resolvedOptions'];
+} & (TOptions$1['context'] extends never ? {
   context?: never;
 } : {
-  context: TOptions['context'];
+  context: TOptions$1['context'];
 });
-type PluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions> & PluginLifecycle<TOptions>;
-type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+type PluginWithLifeCycle<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions$1> & PluginLifecycle<TOptions$1>;
+type PluginLifecycle<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Start of the lifecycle of a plugin.
    * @type hookParallel
    */
-  buildStart?: (this: PluginContext<TOptions>, Config: Config) => PossiblePromise<void>;
+  buildStart?: (this: PluginContext<TOptions$1>, Config: Config) => PossiblePromise<void>;
   /**
    * Resolve to a Path based on a baseName(example: `./Pet.ts`) and directory(example: `./models`).
    * Options can als be included.
    * @type hookFirst
    * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
    */
-  resolvePath?: (this: PluginContext<TOptions>, baseName: BaseName, mode?: Mode, options?: TOptions['resolvePathOptions']) => OptionalPath;
+  resolvePath?: (this: PluginContext<TOptions$1>, baseName: BaseName, mode?: Mode, options?: TOptions$1['resolvePathOptions']) => OptionalPath;
   /**
    * Resolve to a name based on a string.
    * Useful when converting to PascalCase or camelCase.
    * @type hookFirst
    * @example ('pet') => 'Pet'
    */
-  resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+  resolveName?: (this: PluginContext<TOptions$1>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
   /**
    * End of the plugin lifecycle.
    * @type hookParallel
    */
-  buildEnd?: (this: PluginContext<TOptions>) => PossiblePromise<void>;
+  buildEnd?: (this: PluginContext<TOptions$1>) => PossiblePromise<void>;
 };
 type PluginLifecycleHooks = keyof PluginLifecycle;
-type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
-type ResolvePathParams<TOptions = object> = {
+type PluginParameter<H$1 extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H$1]>;
+type ResolvePathParams<TOptions$1 = object> = {
   pluginKey?: Plugin['key'];
   baseName: BaseName;
   mode?: Mode;
   /**
    * Options to be passed to 'resolvePath' 3th parameter
    */
-  options?: TOptions;
+  options?: TOptions$1;
 };
 type ResolveNameParams = {
   name: string;
@@ -455,12 +454,15 @@ type ResolveNameParams = {
    */
   type?: 'file' | 'function' | 'type' | 'const';
 };
-type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+type PluginContext<TOptions$1 extends PluginFactoryOptions = PluginFactoryOptions> = {
   config: Config;
+  /**
+   * @deprecated
+   */
   fileManager: FileManager;
   pluginManager: PluginManager;
   addFile: (...file: Array<File>) => Promise<Array<ResolvedFile>>;
-  resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => OptionalPath;
+  resolvePath: (params: ResolvePathParams<TOptions$1['resolvePathOptions']>) => OptionalPath;
   resolveName: (params: ResolveNameParams) => string;
   logger: Logger;
   /**
@@ -470,12 +472,12 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
   /**
    * Current plugin
    */
-  plugin: Plugin<TOptions>;
+  plugin: Plugin<TOptions$1>;
 };
 /**
  * Specify the export location for the files and define the behavior of the output
  */
-type Output<TOptions> = {
+type Output<TOptions$1> = {
   /**
    * Path to the output folder or file that will contain the generated code
    */
@@ -488,11 +490,11 @@ type Output<TOptions> = {
   /**
    * Add a banner text in the beginning of every file
    */
-  banner?: string | ((options: TOptions) => string);
+  banner?: string | ((options: TOptions$1) => string);
   /**
    * Add a footer text in the beginning of every file
    */
-  footer?: string | ((options: TOptions) => string);
+  footer?: string | ((options: TOptions$1) => string);
 };
 type GroupContext = {
   group: string;
@@ -508,73 +510,19 @@ type Group = {
   name?: (context: GroupContext) => string;
 };
 //#endregion
-//#region ../core/src/FileManager.d.ts
-type FileMetaBase = {
-  pluginKey?: Plugin['key'];
-};
-type AddResult<T extends Array<File>> = Promise<Awaited<GreaterThan<T['length'], 1> extends true ? Promise<ResolvedFile[]> : Promise<ResolvedFile>>>;
-type AddIndexesProps = {
-  type: BarrelType | false | undefined;
-  /**
-   * Root based on root and output.path specified in the config
-   */
-  root: string;
-  /**
-   * Output for plugin
-   */
-  output: {
-    path: string;
-  };
-  group?: {
-    output: string;
-    exportAs: string;
-  };
-  logger?: Logger;
-  meta?: FileMetaBase;
-};
-type WriteFilesProps = {
-  root: Config['root'];
-  extension?: Record<Extname, Extname | ''>;
-  logger?: Logger;
-  dryRun?: boolean;
-};
-declare class FileManager {
-  #private;
-  constructor();
-  add<T extends Array<File> = Array<File>>(...files: T): AddResult<T>;
-  getByPath(path: Path): Promise<ResolvedFile | null>;
-  deleteByPath(path: Path): Promise<void>;
-  clear(): Promise<void>;
-  getFiles(): Promise<Array<ResolvedFile>>;
-  processFiles({
-    dryRun,
-    root,
-    extension,
-    logger
-  }: WriteFilesProps): Promise<Array<ResolvedFile>>;
-  getBarrelFiles({
-    type,
-    meta,
-    root,
-    output,
-    logger
-  }: AddIndexesProps): Promise<File[]>;
-  static getMode(path: string | undefined | null): Mode;
-}
-//#endregion
 //#region ../core/src/PluginManager.d.ts
 type RequiredPluginLifecycle = Required<PluginLifecycle>;
 type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq';
-type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+type Executer<H$1 extends PluginLifecycleHooks = PluginLifecycleHooks> = {
   message: string;
   strategy: Strategy;
-  hookName: H;
+  hookName: H$1;
   plugin: Plugin;
   parameters?: unknown[] | undefined;
   output?: unknown;
 };
-type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H];
-type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
+type ParseResult<H$1 extends PluginLifecycleHooks> = RequiredPluginLifecycle[H$1];
+type SafeParseResult<H$1 extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H$1>>> = {
   result: Result;
   plugin: Plugin;
 };
@@ -590,16 +538,19 @@ type Events = {
   executed: [executer: Executer];
   error: [error: Error];
 };
-type GetFileProps<TOptions = object> = {
+type GetFileProps<TOptions$1 = object> = {
   name: string;
   mode?: Mode;
   extname: Extname;
   pluginKey: Plugin['key'];
-  options?: TOptions;
+  options?: TOptions$1;
 };
 declare class PluginManager {
   #private;
   readonly plugins: Set<Plugin<PluginFactoryOptions<string, object, object, any, object>>>;
+  /**
+   * @deprecated do not use from pluginManager
+   */
   readonly fileManager: FileManager;
   readonly events: EventEmitter<Events>;
   readonly config: Config;
@@ -708,6 +659,11 @@ declare class PluginManager {
   static get hooks(): readonly ["buildStart", "resolvePath", "resolveName", "buildEnd"];
 }
 //#endregion
+//#region ../core/src/FileManager.d.ts
+type FileMetaBase = {
+  pluginKey?: Plugin['key'];
+};
+//#endregion
 //#region ../plugin-oas/src/SchemaMapper.d.ts
 type SchemaKeywordMapper = {
   object: {
@@ -1001,12 +957,12 @@ type ByContentType = {
 };
 type Exclude$1 = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
 type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
-type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
-  options: Partial<TOptions>;
+type Override<TOptions$1> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
+  options: Partial<TOptions$1>;
 };
 //#endregion
 //#region ../plugin-oas/src/SchemaGenerator.d.ts
-type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+type Context$1<TOptions$1, TPluginOptions extends PluginFactoryOptions> = {
   oas: Oas;
   pluginManager: PluginManager;
   /**
@@ -1015,7 +971,7 @@ type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
   plugin: Plugin<TPluginOptions>;
   mode: Mode;
   include?: Array<'schemas' | 'responses' | 'requestBodies'>;
-  override: Array<Override<TOptions>> | undefined;
+  override: Array<Override<TOptions$1>> | undefined;
   contentType?: contentType;
   output?: string;
 };
@@ -1046,7 +1002,7 @@ type SchemaProps$1 = {
   name?: string;
   parentName?: string;
 };
-declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TOptions, Context$1<TOptions, TPluginOptions>> {
+declare class SchemaGenerator<TOptions$1 extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TOptions$1, Context$1<TOptions$1, TPluginOptions>> {
   #private;
   refs: Refs;
   /**
@@ -1065,39 +1021,39 @@ declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGe
 }
 //#endregion
 //#region ../plugin-oas/src/generator.d.ts
-type OperationsProps<TOptions extends PluginFactoryOptions> = {
-  instance: Omit<OperationGenerator<TOptions>, 'build'>;
-  options: TOptions['resolvedOptions'];
+type OperationsProps<TOptions$1 extends PluginFactoryOptions> = {
+  instance: Omit<OperationGenerator<TOptions$1>, 'build'>;
+  options: TOptions$1['resolvedOptions'];
   operations: Array<Operation$1>;
 };
-type OperationProps<TOptions extends PluginFactoryOptions> = {
-  instance: Omit<OperationGenerator<TOptions>, 'build'>;
-  options: TOptions['resolvedOptions'];
+type OperationProps<TOptions$1 extends PluginFactoryOptions> = {
+  instance: Omit<OperationGenerator<TOptions$1>, 'build'>;
+  options: TOptions$1['resolvedOptions'];
   operation: Operation$1;
 };
-type SchemaProps<TOptions extends PluginFactoryOptions> = {
-  instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
-  options: TOptions['resolvedOptions'];
+type SchemaProps<TOptions$1 extends PluginFactoryOptions> = {
+  instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions$1>, 'build'>;
+  options: TOptions$1['resolvedOptions'];
   schema: {
     name: string;
     tree: Array<Schema>;
     value: SchemaObject$1;
   };
 };
-type GeneratorOptions<TOptions extends PluginFactoryOptions> = {
+type GeneratorOptions<TOptions$1 extends PluginFactoryOptions> = {
   name: string;
-  operations?: (this: GeneratorOptions<TOptions>, props: OperationsProps<TOptions>) => Promise<File[]>;
-  operation?: (this: GeneratorOptions<TOptions>, props: OperationProps<TOptions>) => Promise<File[]>;
-  schema?: (this: GeneratorOptions<TOptions>, props: SchemaProps<TOptions>) => Promise<File[]>;
+  operations?: (this: GeneratorOptions<TOptions$1>, props: OperationsProps<TOptions$1>) => Promise<File[]>;
+  operation?: (this: GeneratorOptions<TOptions$1>, props: OperationProps<TOptions$1>) => Promise<File[]>;
+  schema?: (this: GeneratorOptions<TOptions$1>, props: SchemaProps<TOptions$1>) => Promise<File[]>;
 };
-type Generator<TOptions extends PluginFactoryOptions> = GeneratorOptions<TOptions>;
+type Generator<TOptions$1 extends PluginFactoryOptions> = GeneratorOptions<TOptions$1>;
 //#endregion
 //#region ../plugin-oas/src/OperationGenerator.d.ts
-type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+type Context<TOptions$1, TPluginOptions extends PluginFactoryOptions> = {
   oas: Oas;
   exclude: Array<Exclude$1> | undefined;
   include: Array<Include> | undefined;
-  override: Array<Override<TOptions>> | undefined;
+  override: Array<Override<TOptions$1>> | undefined;
   contentType: contentType | undefined;
   pluginManager: PluginManager;
   /**
@@ -1181,5 +1137,5 @@ type ResolvedOptions = {
 };
 type PluginMsw = PluginFactoryOptions<'plugin-msw', Options$1, ResolvedOptions, never, ResolvePathOptions>;
 //#endregion
-export { Generator, Options$1 as Options, PluginMsw, UserPluginWithLifeCycle };
-//# sourceMappingURL=types-DLxzBV0T.d.cts.map
+export { UserPluginWithLifeCycle as i, PluginMsw as n, Generator as r, Options$1 as t };
+//# sourceMappingURL=types-BLiYk9M7.d.ts.map

package/dist/{types-DYAniEBx.d.cts → types-IbHKcY02.d.ts}

@@ -9,5 +9,5 @@ type SchemaObject$1 = OasTypes.SchemaObject & {
   $ref?: string;
 };
 //#endregion
-export { type HttpMethod, type OasTypes, type Operation$1 as Operation, SchemaObject$1 as SchemaObject, contentType };
-//# sourceMappingURL=types-DYAniEBx.d.cts.map
+export { contentType as a, SchemaObject$1 as i, OasTypes as n, Operation$1 as r, HttpMethod as t };
+//# sourceMappingURL=types-IbHKcY02.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-msw",
-  "version": "4.1.4",
+  "version": "4.2.1",
   "description": "Mock Service Worker (MSW) handlers generator plugin for Kubb, creating API mocks from OpenAPI specifications for frontend development and testing.",
   "keywords": [
     "msw",
@@ -66,17 +66,15 @@
     "!/**/__tests__/**"
   ],
   "dependencies": {
-    "@kubb/core": "4.1.4",
-    "@kubb/oas": "4.1.4",
-    "@kubb/plugin-faker": "4.1.4",
-    "@kubb/plugin-oas": "4.1.4",
-    "@kubb/plugin-ts": "4.1.4",
-    "@kubb/react": "4.1.4"
+    "@kubb/core": "4.2.1",
+    "@kubb/oas": "4.2.1",
+    "@kubb/plugin-faker": "4.2.1",
+    "@kubb/plugin-oas": "4.2.1",
+    "@kubb/plugin-ts": "4.2.1",
+    "@kubb/react": "4.2.1"
   },
   "devDependencies": {
-    "@types/react": "^18.3.26",
-    "react": "^18.3.1",
-    "tsdown": "^0.14.2",
+    "tsdown": "^0.15.9",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {

package/src/components/Handlers.tsx

@@ -1,5 +1,4 @@
 import { File } from '@kubb/react'
-import type { ReactNode } from 'react'
 
 type HandlersProps = {
   /**
@@ -10,7 +9,7 @@ type HandlersProps = {
   handlers: string[]
 }
 
-export function Handlers({ name, handlers }: HandlersProps): ReactNode {
+export function Handlers({ name, handlers }: HandlersProps) {
   return (
     <File.Source name={name} isIndexable isExportable>
       {`export const ${name} = ${JSON.stringify(handlers).replaceAll(`"`, '')} as const`}

package/src/components/Mock.tsx

@@ -1,7 +1,6 @@
 import { URLPath } from '@kubb/core/utils'
 import type { OasTypes, Operation } from '@kubb/oas'
 import { File, Function, FunctionParams } from '@kubb/react'
-import type { ReactNode } from 'react'
 
 type Props = {
   /**
@@ -14,7 +13,7 @@ type Props = {
   operation: Operation
 }
 
-export function Mock({ baseURL = '', name, typeName, operation }: Props): ReactNode {
+export function Mock({ baseURL = '', name, typeName, operation }: Props) {
   const method = operation.method
   const successStatusCodes = operation.getResponseStatusCodes().filter((code) => code.startsWith('2'))
   const statusCode = successStatusCodes.length > 0 ? Number(successStatusCodes[0]) : 200

package/src/components/MockWithFaker.tsx

@@ -2,7 +2,6 @@ import { URLPath } from '@kubb/core/utils'
 
 import type { OasTypes, Operation } from '@kubb/oas'
 import { File, Function, FunctionParams } from '@kubb/react'
-import type { ReactNode } from 'react'
 
 type Props = {
   /**
@@ -15,7 +14,7 @@ type Props = {
   operation: Operation
 }
 
-export function MockWithFaker({ baseURL = '', name, fakerName, typeName, operation }: Props): ReactNode {
+export function MockWithFaker({ baseURL = '', name, fakerName, typeName, operation }: Props) {
   const method = operation.method
   const successStatusCodes = operation.getResponseStatusCodes().filter((code) => code.startsWith('2'))
   const statusCode = successStatusCodes.length > 0 ? Number(successStatusCodes[0]) : 200

package/src/components/Response.tsx

@@ -0,0 +1,42 @@
+import type { OasTypes, Operation } from '@kubb/oas'
+import { File, Function, FunctionParams } from '@kubb/react'
+
+type Props = {
+  typeName: string
+  operation: Operation
+  name: string
+  statusCode: number
+}
+
+export function Response({ name, typeName, operation, statusCode }: Props) {
+  const responseObject = operation.getResponseByStatusCode(statusCode) as OasTypes.ResponseObject
+  const contentType = Object.keys(responseObject.content || {})?.[0]
+
+  const headers = [contentType ? `'Content-Type': '${contentType}'` : undefined].filter(Boolean)
+
+  const params = FunctionParams.factory({
+    data: {
+      type: `${typeName}`,
+    },
+  })
+
+  const responseName = `${name}Response${statusCode}`
+
+  return (
+    <File.Source name={responseName} isIndexable isExportable>
+      <Function name={responseName} export params={params.toConstructor()}>
+        {`
+    return new Response(JSON.stringify(data), {
+      status: ${statusCode},
+      ${
+        headers.length
+          ? `  headers: {
+        ${headers.join(', \n')}
+      },`
+          : ''
+      }
+    })`}
+      </Function>
+    </File.Source>
+  )
+}

package/src/components/index.ts

@@ -1,3 +1,4 @@
 export { Mock } from './Mock.tsx'
 export { Handlers } from './Handlers.tsx'
 export { MockWithFaker } from './MockWithFaker.tsx'
+export { Response } from './Response.tsx'

package/src/generators/__snapshots__/createPet.ts

@@ -4,6 +4,12 @@
  */
 import { http } from 'msw'
 
+export function createPetsResponse201(data: CreatePetsMutationResponse) {
+  return new Response(JSON.stringify(data), {
+    status: 201,
+  })
+}
+
 export function createPets(data?: CreatePetsMutationResponse | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Response | Promise<Response>)) {
   return http.post('/pets', function handler(info) {
     if (typeof data === 'function') return data(info)

package/src/generators/__snapshots__/createPetFaker.ts

@@ -4,6 +4,12 @@
  */
 import { http } from 'msw'
 
+export function createPetsResponse201(data: CreatePetsMutationResponse) {
+  return new Response(JSON.stringify(data), {
+    status: 201,
+  })
+}
+
 export function createPets(data?: CreatePetsMutationResponse | ((info: Parameters<Parameters<typeof http.post>[1]>[0]) => Response | Promise<Response>)) {
   return http.post('/pets', function handler(info) {
     if (typeof data === 'function') return data(info)

package/src/generators/__snapshots__/getPets.ts

@@ -4,6 +4,21 @@
  */
 import { http } from 'msw'
 
+export function listPetsResponse200(data: ListPetsQueryResponse) {
+  return new Response(JSON.stringify(data), {
+    status: 200,
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  })
+}
+
+export function listPetsResponse400(data: ListPets400) {
+  return new Response(JSON.stringify(data), {
+    status: 400,
+  })
+}
+
 export function listPets(data?: ListPetsQueryResponse | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Response | Promise<Response>)) {
   return http.get('/pets', function handler(info) {
     if (typeof data === 'function') return data(info)

package/src/generators/__snapshots__/getPetsFaker.ts

@@ -4,6 +4,21 @@
  */
 import { http } from 'msw'
 
+export function listPetsResponse200(data: ListPetsQueryResponse) {
+  return new Response(JSON.stringify(data), {
+    status: 200,
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  })
+}
+
+export function listPetsResponse400(data: ListPets400) {
+  return new Response(JSON.stringify(data), {
+    status: 400,
+  })
+}
+
 export function listPets(data?: ListPetsQueryResponse | ((info: Parameters<Parameters<typeof http.get>[1]>[0]) => Response | Promise<Response>)) {
   return http.get('/pets', function handler(info) {
     if (typeof data === 'function') return data(info)