@effect/language-service 0.14.0 → 0.15.1

package/README.md

@@ -46,10 +46,12 @@ Your `tsconfig.json` should look like this:
 }
 ```
 
+To get diagnostics you need to install `ts-patch` which will make it possible to run `tspc`.
+
 Running `tspc` in your project will now also run the plugin and give you the diagnostics at compile time.
 
 ```ts
-$ npm tspc
+$ npx tspc
 index.ts:3:1 - error TS3: Effect must be yielded or assigned to a variable.
 
 3 Effect.succeed(1)

package/index.js

@@ -1,8 +1,8 @@
 "use strict";
 var __defProp = Object.defineProperty;
-var __export = (target, all2) => {
-  for (var name in all2)
-    __defProp(target, name, { get: all2[name], enumerable: true });
+var __export = (target, all3) => {
+  for (var name in all3)
+    __defProp(target, name, { get: all3[name], enumerable: true });
 };
 
 // node_modules/.pnpm/effect@3.12.5/node_modules/effect/dist/esm/Function.js
@@ -1004,23 +1004,27 @@ var contextGet = (context, tag) => {
   }
   return none2();
 };
-var Nano = class {
-  constructor(run2) {
-    this.run = run2;
-  }
+var Proto = {
+  run: () => {
+  },
   [Symbol.iterator]() {
     return new SingleShotGen(new YieldWrap(this));
   }
 };
+function make3(run2) {
+  const result = Object.create(Proto);
+  result.run = run2;
+  return result;
+}
 var unsafeRun = (fa) => {
   const result = fa.run(contextEmpty);
   switch (result._tag) {
     case "Left":
-      return left2(result.left);
+      return left2(result.value);
     case "Defect":
-      return left2(new NanoDefectException(result.defect));
+      return left2(new NanoDefectException(result.value));
     case "Right":
-      return right2(result.right);
+      return right2(result.value);
   }
 };
 var run = (fa) => {
@@ -1030,35 +1034,35 @@ var run = (fa) => {
     return left2(new NanoDefectException(e));
   }
 };
-var succeed = (value) => new Nano(() => ({ _tag: "Right", right: value }));
-var fail = (value) => new Nano(() => ({ _tag: "Left", left: value }));
-var sync = (value) => new Nano(() => ({ _tag: "Right", right: value() }));
-var flatMap3 = dual(2, (fa, f) => new Nano((ctx) => {
+var succeed = (value) => make3(() => ({ _tag: "Right", value }));
+var fail = (value) => make3(() => ({ _tag: "Left", value }));
+var sync = (value) => make3(() => ({ _tag: "Right", value: value() }));
+var flatMap3 = dual(2, (fa, f) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
-  return f(result.right).run(ctx);
+  return f(result.value).run(ctx);
 }));
-var map3 = dual(2, (fa, f) => new Nano((ctx) => {
+var map3 = dual(2, (fa, f) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
-  return { _tag: "Right", right: f(result.right) };
+  return { _tag: "Right", value: f(result.value) };
 }));
-var orElse3 = (f) => (fa) => new Nano((ctx) => {
+var orElse3 = (f) => (fa) => make3((ctx) => {
   const result = fa.run(ctx);
-  if (result._tag === "Left") return f().run(ctx);
+  if (result._tag === "Left") return f(result.value).run(ctx);
   return result;
 });
 var firstSuccessOf = (arr) => reduce(arr.slice(1), arr[0], (arr2, fa) => orElse3(() => fa)(arr2));
-var service = (tag) => new Nano(
+var service = (tag) => make3(
   (ctx) => contextGet(ctx, tag).pipe(match2({
-    onNone: () => ({ _tag: "Defect", defect: `Cannot find service ${tag.key}` }),
-    onSome: (value) => ({ _tag: "Right", right: value })
+    onNone: () => ({ _tag: "Defect", value: `Cannot find service ${tag.key}` }),
+    onSome: (value) => ({ _tag: "Right", value })
   }))
 );
-var provideService = (tag, value) => (fa) => new Nano((ctx) => {
+var provideService = (tag, value) => (fa) => make3((ctx) => {
   return fa.run(contextAdd(ctx, tag, value));
 });
-var gen2 = (...args) => new Nano((ctx) => {
+var gen2 = (...args) => make3((ctx) => {
   const iterator = args[0]();
   let state = iterator.next();
   while (!state.done) {
@@ -1067,11 +1071,11 @@ var gen2 = (...args) => new Nano((ctx) => {
     if (result._tag !== "Right") {
       return result;
     }
-    state = iterator.next(result.right);
+    state = iterator.next(result.value);
   }
-  return { _tag: "Right", right: state.value };
+  return { _tag: "Right", value: state.value };
 });
-var fn = (_) => (body) => (...args) => new Nano((ctx) => {
+var fn = (_) => (body) => (...args) => make3((ctx) => {
   const iterator = body(...args);
   let state = iterator.next();
   while (!state.done) {
@@ -1080,21 +1084,29 @@ var fn = (_) => (body) => (...args) => new Nano((ctx) => {
     if (result._tag !== "Right") {
       return result;
     }
-    state = iterator.next(result.right);
+    state = iterator.next(result.value);
   }
-  return { _tag: "Right", right: state.value };
+  return { _tag: "Right", value: state.value };
 });
-var option = (fa) => new Nano((ctx) => {
+var option = (fa) => make3((ctx) => {
   const result = fa.run(ctx);
   switch (result._tag) {
     case "Right":
-      return { _tag: "Right", right: some2(result.right) };
+      return { _tag: "Right", value: some2(result.value) };
     case "Left":
-      return { _tag: "Right", right: none2() };
+      return { _tag: "Right", value: none2() };
     case "Defect":
       return result;
   }
 });
+var all2 = (...args) => gen2(function* () {
+  const results = [];
+  for (const arg of args) {
+    const result = yield* arg;
+    results.push(result);
+  }
+  return results;
+});
 
 // src/core/TypeScriptApi.ts
 var TypeScriptApi = Tag("TypeScriptApi");
@@ -3511,6 +3523,491 @@ var toggleTypeAnnotation = createRefactor({
   })
 });
 
+// src/utils/SchemaGen.ts
+var TypeParametersNotSupportedError = class {
+  constructor(node) {
+    this.node = node;
+  }
+  _tag = "@effect/language-service/TypeParametersNotSupportedError";
+  toString() {
+    return `Could not process types with type parameters.`;
+  }
+};
+var OnlyLiteralPropertiesSupportedError = class {
+  constructor(node) {
+    this.node = node;
+  }
+  _tag = "@effect/language-service/OnlyLiteralPropertiesSupportedError";
+  toString() {
+    return `Could not process ${this.node.getText()} as only literal properties are supported.`;
+  }
+};
+var RequiredExplicitTypesError = class {
+  constructor(node) {
+    this.node = node;
+  }
+  _tag = "@effect/language-service/RequiredExplicitTypesError";
+  toString() {
+    return `Could not process ${this.node.getText()} as only explicit types are supported.`;
+  }
+};
+var IndexSignatureWithMoreThanOneParameterError = class {
+  constructor(node) {
+    this.node = node;
+  }
+  _tag = "@effect/language-service/IndexSignatureWithMoreThanOneParameterError";
+  toString() {
+    return `Could not process ${this.node.getText()} as only index signatures with one parameter are supported.`;
+  }
+};
+var SchemaGenContext = Tag("SchemaGenContext");
+var makeSchemaGenContext = fn("SchemaGen.makeSchemaGenContext")(function* (sourceFile) {
+  const effectSchemaIdentifier = pipe(
+    yield* option(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Schema")
+    ),
+    match2({
+      onNone: () => "Schema",
+      onSome: (_) => _.text
+    })
+  );
+  const moduleToImportedName = {};
+  for (const moduleName of ["Option", "Either", "Chunk", "Duration"]) {
+    const importedName = yield* option(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", moduleName)
+    );
+    if (isSome2(importedName)) moduleToImportedName[moduleName] = importedName.value.text;
+  }
+  const ts = yield* service(TypeScriptApi);
+  return {
+    sourceFile,
+    createApiPropertyAccess: (apiName) => ts.factory.createPropertyAccessExpression(
+      ts.factory.createIdentifier(effectSchemaIdentifier),
+      apiName
+    ),
+    createApiCall: (apiName, args) => ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectSchemaIdentifier),
+        apiName
+      ),
+      [],
+      args
+    ),
+    entityNameToDataTypeName: (name) => {
+      if (ts.isIdentifier(name)) {
+        switch (name.text) {
+          case "Date":
+          case "Pick":
+          case "Omit":
+          case "Record":
+            return some2(name.text);
+          case "ReadonlyArray":
+          case "Array":
+            return some2("Array");
+        }
+        return none2();
+      }
+      if (!ts.isIdentifier(name.left)) return none2();
+      for (const moduleName in moduleToImportedName) {
+        if (name.left.text === moduleToImportedName[moduleName] && name.right.text === moduleName) {
+          return some2(moduleName);
+        }
+      }
+      return none2();
+    },
+    ts
+  };
+});
+var typeEntityNameToNode = fn(
+  "SchemaGen.typeEntityNameToNode"
+)(
+  function* (entityName) {
+    const { ts } = yield* service(SchemaGenContext);
+    if (ts.isIdentifier(entityName)) return ts.factory.createIdentifier(entityName.text);
+    const left3 = yield* typeEntityNameToNode(entityName.left);
+    return ts.factory.createPropertyAccessExpression(
+      left3,
+      ts.factory.createIdentifier(entityName.right.text)
+    );
+  }
+);
+var parseAllLiterals = fn(
+  "SchemaGen.parseAllLiterals"
+)(
+  function* (node) {
+    const { ts } = yield* service(SchemaGenContext);
+    if (ts.isLiteralTypeNode(node)) {
+      switch (node.literal.kind) {
+        case ts.SyntaxKind.StringLiteral:
+          return [ts.factory.createStringLiteral(node.literal.text)];
+        case ts.SyntaxKind.NumericLiteral:
+          return [ts.factory.createNumericLiteral(node.literal.text)];
+        case ts.SyntaxKind.TrueKeyword:
+          return [ts.factory.createTrue()];
+        case ts.SyntaxKind.FalseKeyword:
+          return [ts.factory.createFalse()];
+      }
+    }
+    if (ts.isUnionTypeNode(node)) {
+      return flatten(yield* all2(...node.types.map((_) => parseAllLiterals(_))));
+    }
+    if (ts.isParenthesizedTypeNode(node)) {
+      return yield* parseAllLiterals(node.type);
+    }
+    return yield* fail(node);
+  }
+);
+var createUnsupportedNodeComment = (ts, sourceFile, node) => ts.addSyntheticTrailingComment(
+  ts.factory.createIdentifier(""),
+  ts.SyntaxKind.MultiLineCommentTrivia,
+  " Not supported conversion: " + node.getText(sourceFile) + " "
+);
+var processNode = (node) => gen2(function* () {
+  const { createApiCall, createApiPropertyAccess, entityNameToDataTypeName, sourceFile, ts } = yield* service(
+    SchemaGenContext
+  );
+  switch (node.kind) {
+    case ts.SyntaxKind.AnyKeyword:
+      return createApiPropertyAccess("Any");
+    case ts.SyntaxKind.NeverKeyword:
+      return createApiPropertyAccess("Never");
+    case ts.SyntaxKind.UnknownKeyword:
+      return createApiPropertyAccess("Unknown");
+    case ts.SyntaxKind.VoidKeyword:
+      return createApiPropertyAccess("Void");
+    case ts.SyntaxKind.NullKeyword:
+      return createApiPropertyAccess("Null");
+    case ts.SyntaxKind.UndefinedKeyword:
+      return createApiPropertyAccess("Undefined");
+    case ts.SyntaxKind.StringKeyword:
+      return createApiPropertyAccess("String");
+    case ts.SyntaxKind.NumberKeyword:
+      return createApiPropertyAccess("Number");
+    case ts.SyntaxKind.BooleanKeyword:
+      return createApiPropertyAccess("Boolean");
+    case ts.SyntaxKind.BigIntKeyword:
+      return createApiPropertyAccess("BigInt");
+  }
+  if (ts.isLiteralTypeNode(node)) {
+    if (node.literal.kind === ts.SyntaxKind.NullKeyword) return createApiPropertyAccess("Null");
+    const literalMembers = yield* option(parseAllLiterals(node));
+    if (isSome2(literalMembers)) return createApiCall("Literal", literalMembers.value);
+  }
+  if (ts.isUnionTypeNode(node)) {
+    const allLiterals = yield* option(parseAllLiterals(node));
+    if (isSome2(allLiterals)) return createApiCall("Literal", allLiterals.value);
+    const members = yield* all2(...node.types.map((_) => processNode(_)));
+    return createApiCall("Union", members);
+  }
+  if (ts.isIntersectionTypeNode(node)) {
+    const [firstSchema, ...otherSchemas] = yield* all2(
+      ...node.types.map((_) => processNode(_))
+    );
+    if (otherSchemas.length === 0) return firstSchema;
+    return ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        firstSchema,
+        "pipe"
+      ),
+      [],
+      otherSchemas.map((_) => createApiCall("extend", [_]))
+    );
+  }
+  if (ts.isArrayTypeNode(node)) {
+    const typeSchema = yield* processNode(node.elementType);
+    return createApiCall("Array", [typeSchema]);
+  }
+  if (ts.isTypeLiteralNode(node)) {
+    const { properties, records } = yield* processMembers(node.members);
+    return createApiCall(
+      "Struct",
+      [ts.factory.createObjectLiteralExpression(properties, true)].concat(records)
+    );
+  }
+  if (ts.isTypeReferenceNode(node)) {
+    const parsedName = entityNameToDataTypeName(node.typeName);
+    if (isSome2(parsedName)) {
+      switch (parsedName.value) {
+        case "Duration":
+        case "Date":
+          return createApiPropertyAccess(parsedName.value);
+        case "Option":
+        case "Chunk":
+        case "Array": {
+          const elements = yield* all2(
+            ...node.typeArguments ? node.typeArguments.map(processNode) : []
+          );
+          return createApiCall(parsedName.value, elements);
+        }
+        case "Record": {
+          const elements = yield* all2(
+            ...node.typeArguments ? node.typeArguments.map(processNode) : []
+          );
+          if (elements.length >= 2) {
+            return createApiCall(parsedName.value, [
+              ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment("key", elements[0]),
+                ts.factory.createPropertyAssignment("value", elements[1])
+              ])
+            ]);
+          }
+          return createUnsupportedNodeComment(ts, sourceFile, node);
+        }
+        case "Either": {
+          const elements = yield* all2(
+            ...node.typeArguments ? node.typeArguments.map(processNode) : []
+          );
+          if (elements.length >= 2) {
+            return createApiCall(parsedName.value, [
+              ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment("right", elements[0]),
+                ts.factory.createPropertyAssignment("left", elements[1])
+              ])
+            ]);
+          }
+          return createUnsupportedNodeComment(ts, sourceFile, node);
+        }
+        case "Pick":
+        case "Omit": {
+          const typeArguments = fromIterable(node.typeArguments || []);
+          if (typeArguments.length !== 2) {
+            return createUnsupportedNodeComment(ts, sourceFile, node);
+          }
+          const baseType = yield* processNode(typeArguments[0]);
+          const stringLiteralArguments = yield* option(parseAllLiterals(typeArguments[1]));
+          if (isNone2(stringLiteralArguments)) {
+            return createUnsupportedNodeComment(ts, sourceFile, node);
+          }
+          return ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              baseType,
+              "pipe"
+            ),
+            [],
+            [createApiCall(parsedName.value.toLowerCase(), stringLiteralArguments.value)]
+          );
+        }
+      }
+    }
+  }
+  if (ts.isTypeReferenceNode(node)) {
+    if (!(node.typeArguments && node.typeArguments.length > 0)) {
+      return yield* typeEntityNameToNode(node.typeName);
+    }
+  }
+  return createUnsupportedNodeComment(ts, sourceFile, node);
+});
+var processMembers = fn(
+  "SchemaGen.processMembers"
+)(
+  function* (members) {
+    const { createApiCall, ts } = yield* service(
+      SchemaGenContext
+    );
+    const properties = [];
+    for (const propertySignature of members.filter(ts.isPropertySignature)) {
+      const name = propertySignature.name;
+      if (!(ts.isIdentifier(name) || ts.isStringLiteral(name))) {
+        return yield* fail(new OnlyLiteralPropertiesSupportedError(propertySignature));
+      }
+      if (!propertySignature.type) {
+        return yield* fail(new RequiredExplicitTypesError(propertySignature));
+      }
+      const propertyAssignment = pipe(
+        yield* processNode(propertySignature.type),
+        propertySignature.questionToken ? (_) => createApiCall("optional", [_]) : identity,
+        (_) => ts.factory.createPropertyAssignment(name, _)
+      );
+      properties.push(propertyAssignment);
+    }
+    const records = [];
+    for (const indexSignature of members.filter(ts.isIndexSignatureDeclaration)) {
+      if (indexSignature.parameters.length !== 1) {
+        return yield* fail(new IndexSignatureWithMoreThanOneParameterError(indexSignature));
+      }
+      const parameter = indexSignature.parameters[0];
+      if (!parameter.type) return yield* fail(new RequiredExplicitTypesError(parameter));
+      const parameterType = parameter.type;
+      const key = yield* processNode(parameterType);
+      const value = yield* processNode(indexSignature.type);
+      records.push(
+        ts.factory.createObjectLiteralExpression([
+          ts.factory.createPropertyAssignment("key", key),
+          ts.factory.createPropertyAssignment("value", value)
+        ])
+      );
+    }
+    return { properties, records };
+  }
+);
+var processInterfaceDeclaration = fn("SchemaGen.processInterfaceDeclaration")(
+  function* (node, preferClass) {
+    if (node.typeParameters && node.typeParameters.length > 0) {
+      return yield* fail(new TypeParametersNotSupportedError(node));
+    }
+    const { createApiCall, ts } = yield* service(
+      SchemaGenContext
+    );
+    const { properties, records } = yield* processMembers(node.members);
+    if (preferClass && records.length === 0) {
+      return yield* createExportSchemaClassDeclaration(node.name.text, properties);
+    }
+    const schemaStruct = createApiCall(
+      "Struct",
+      [ts.factory.createObjectLiteralExpression(properties, true)].concat(records)
+    );
+    return yield* createExportVariableDeclaration(node.name.text, schemaStruct);
+  }
+);
+var processTypeAliasDeclaration = fn("SchemaGen.processInterfaceDeclaration")(
+  function* (node, preferClass) {
+    const { ts } = yield* service(SchemaGenContext);
+    if (node.typeParameters && node.typeParameters.length > 0) {
+      return yield* fail(new TypeParametersNotSupportedError(node));
+    }
+    if (preferClass && ts.isTypeLiteralNode(node.type)) {
+      const { properties, records } = yield* processMembers(node.type.members);
+      if (records.length === 0) {
+        return yield* createExportSchemaClassDeclaration(node.name.text, properties);
+      }
+    }
+    const effectSchema = yield* processNode(node.type);
+    return yield* createExportVariableDeclaration(node.name.text, effectSchema);
+  }
+);
+var createExportVariableDeclaration = fn("SchemaGen.createExportVariableDeclaration")(
+  function* (name, initializer) {
+    const ts = yield* service(TypeScriptApi);
+    return ts.factory.createVariableStatement(
+      [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+      ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(
+          ts.factory.createIdentifier(name),
+          void 0,
+          void 0,
+          initializer
+        )
+      ], ts.NodeFlags.Const)
+    );
+  }
+);
+var createExportSchemaClassDeclaration = fn("SchemaGen.createExportSchemaClassDeclaration")(
+  function* (name, members) {
+    const { createApiPropertyAccess } = yield* service(SchemaGenContext);
+    const ts = yield* service(TypeScriptApi);
+    return ts.factory.createClassDeclaration(
+      [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+      ts.factory.createIdentifier(name),
+      [],
+      [ts.factory.createHeritageClause(
+        ts.SyntaxKind.ExtendsKeyword,
+        [
+          ts.factory.createExpressionWithTypeArguments(
+            ts.factory.createCallExpression(
+              ts.factory.createCallExpression(
+                createApiPropertyAccess("Class"),
+                [ts.factory.createTypeReferenceNode(
+                  name
+                )],
+                [ts.factory.createStringLiteral(name)]
+              ),
+              [],
+              [ts.factory.createObjectLiteralExpression(
+                members,
+                true
+              )]
+            ),
+            []
+          )
+        ]
+      )],
+      []
+    );
+  }
+);
+var process = fn("SchemaGen.process")(
+  function* (sourceFile, node, preferClass) {
+    const ctx = yield* makeSchemaGenContext(sourceFile);
+    const ts = yield* service(TypeScriptApi);
+    return yield* pipe(
+      ts.isInterfaceDeclaration(node) ? processInterfaceDeclaration(node, preferClass) : processTypeAliasDeclaration(node, preferClass),
+      provideService(SchemaGenContext, ctx)
+    );
+  }
+);
+var findNodeToProcess = fn("SchemaGen.findNodeToProcess")(
+  function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    return pipe(
+      yield* getAncestorNodesInRange(sourceFile, textRange),
+      filter((node) => ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)),
+      filter((node) => isNodeInRange(textRange)(node.name)),
+      filter((node) => (node.typeParameters || []).length === 0),
+      head
+    );
+  }
+);
+var applyAtNode = fn("SchemaGen.applyAtNode")(
+  function* (sourceFile, node, preferClass) {
+    const ts = yield* service(TypeScriptApi);
+    const changeTracker = yield* service(ChangeTracker);
+    const newNode = yield* pipe(
+      process(sourceFile, node, preferClass),
+      orElse3(
+        (error) => succeed(ts.addSyntheticLeadingComment(
+          ts.factory.createIdentifier(""),
+          ts.SyntaxKind.MultiLineCommentTrivia,
+          " " + String(error) + " ",
+          true
+        ))
+      )
+    );
+    changeTracker.insertNodeBefore(sourceFile, node, newNode, true, {
+      leadingTriviaOption: ts.textChanges.LeadingTriviaOption.StartLine
+    });
+  }
+);
+
+// src/refactors/typeToEffectSchema.ts
+var typeToEffectSchema = createRefactor({
+  name: "effect/typeToEffectSchema",
+  description: "Refactor to Schema",
+  apply: fn("typeToEffectSchema.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
+    const node = maybeNode.value;
+    return {
+      kind: "refactor.rewrite.effect.typeToEffectSchema",
+      description: "Refactor to Schema",
+      apply: pipe(
+        applyAtNode(sourceFile, node, false),
+        provideService(TypeScriptApi, ts)
+      )
+    };
+  })
+});
+
+// src/refactors/typeToEffectSchemaClass.ts
+var typeToEffectSchemaClass = createRefactor({
+  name: "effect/typeToEffectSchemaClass",
+  description: "Refactor to Schema.Class",
+  apply: fn("typeToEffectSchemaClass.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
+    const node = maybeNode.value;
+    return {
+      kind: "refactor.rewrite.effect.typeToEffectSchemaClass",
+      description: "Refactor to Schema.Class",
+      apply: pipe(
+        applyAtNode(sourceFile, node, true),
+        provideService(TypeScriptApi, ts)
+      )
+    };
+  })
+});
+
 // src/refactors/wrapWithEffectGen.ts
 var wrapWithEffectGen = createRefactor({
   name: "effect/wrapWithEffectGen",
@@ -3601,6 +4098,8 @@ var refactors = [
   asyncAwaitToGen,
   asyncAwaitToGenTryPromise,
   functionToArrow,
+  typeToEffectSchema,
+  typeToEffectSchemaClass,
   makeSchemaOpaque,
   makeSchemaOpaqueWithNs,
   pipeableToDatafirst,