utils

AdapterPrerequisite

A symbol a lifter rule names that does not resolve in the analyzed project.

Signature

declare const AdapterPrerequisite: Schema.Struct<{
  readonly rule: Schema.String
  readonly role: Schema.String
  readonly ref: Schema.Struct<{
    readonly module: Schema.String
    readonly export: Schema.String
    readonly member: Schema.optionalKey<Schema.String>
  }>
}>

AdapterPrerequisite (type alias)

Signature

type AdapterPrerequisite = typeof AdapterPrerequisite.Type

BindingReport

The key-set comparison of an application binding with its group, and what the registrations resolve to. Verification is always UNVERIFIED here: only the real binding typecheck can verify it.

Signature

declare const BindingReport: Schema.Struct<{
  readonly group: Schema.String
  readonly declared: Schema.$Array<Schema.String>
  readonly bound: Schema.$Array<Schema.String>
  readonly missing: Schema.$Array<Schema.String>
  readonly extra: Schema.$Array<Schema.String>
  readonly registrations: Schema.$Array<
    Schema.Struct<{
      readonly key: Schema.String
      readonly kind: Schema.Literals<readonly ["raw", "normal"]>
      readonly handler: Schema.TaggedUnion<{
        readonly Exported: Schema.TaggedStruct<
          "Exported",
          {
            readonly ref: Schema.Struct<{
              readonly module: Schema.String
              readonly export: Schema.String
              readonly member: Schema.optionalKey<Schema.String>
            }>
          }
        >
        readonly Inline: Schema.TaggedStruct<
          "Inline",
          {
            readonly range: Schema.Struct<{
              readonly file: Schema.String
              readonly start: Schema.Struct<{
                readonly offset: Schema.Int
                readonly line: Schema.Int
                readonly col: Schema.Int
              }>
              readonly end: Schema.Struct<{
                readonly offset: Schema.Int
                readonly line: Schema.Int
                readonly col: Schema.Int
              }>
            }>
          }
        >
        readonly Unavailable: Schema.TaggedStruct<
          "Unavailable",
          {
            readonly finding: Schema.Struct<{
              readonly kind: Schema.Literals<
                readonly [
                  "spread",
                  "computed-key",
                  "non-literal",
                  "local-reference",
                  "closure",
                  "unresolved",
                  "unsupported-syntax"
                ]
              >
              readonly construct: Schema.String
              readonly range: Schema.Struct<{
                readonly file: Schema.String
                readonly start: Schema.Struct<{
                  readonly offset: Schema.Int
                  readonly line: Schema.Int
                  readonly col: Schema.Int
                }>
                readonly end: Schema.Struct<{
                  readonly offset: Schema.Int
                  readonly line: Schema.Int
                  readonly col: Schema.Int
                }>
              }>
              readonly enclosingCall: Schema.optionalKey<
                Schema.Struct<{
                  readonly callee: Schema.Struct<{
                    readonly module: Schema.String
                    readonly export: Schema.String
                    readonly member: Schema.optionalKey<Schema.String>
                  }>
                }>
              >
            }>
          }
        >
      }>
    }>
  >
  readonly authorizeCalls: Schema.$Array<
    Schema.Struct<{
      readonly file: Schema.String
      readonly start: Schema.Struct<{
        readonly offset: Schema.Int
        readonly line: Schema.Int
        readonly col: Schema.Int
      }>
      readonly end: Schema.Struct<{ readonly offset: Schema.Int; readonly line: Schema.Int; readonly col: Schema.Int }>
    }>
  >
  readonly verification: Schema.Literal<"UNVERIFIED">
}>

BindingReport (type alias)

Signature

type BindingReport = typeof BindingReport.Type

CodeReference

An exported tuple associated with its exact problem identifier and literal codes, never by name alone.

Signature

declare const CodeReference: Schema.Struct<{
  readonly identifier: Schema.String
  readonly codes: Schema.$Array<Schema.String>
  readonly ref: Schema.Struct<{
    readonly module: Schema.String
    readonly export: Schema.String
    readonly member: Schema.optionalKey<Schema.String>
  }>
}>

CodeReference (type alias)

Signature

type CodeReference = typeof CodeReference.Type

Decision

A semantic fact of the lift with no Effect twin, printed for review and never reported as verified.

Signature

declare const Decision: Schema.TaggedUnion<{
  readonly OperationKind: Schema.TaggedStruct<
    "OperationKind",
    {
      readonly subject: Schema.String
      readonly kind: Schema.Literals<readonly ["Query", "Command"]>
      readonly method: Schema.String
    }
  >
  readonly OperationInput: Schema.TaggedStruct<
    "OperationInput",
    {
      readonly subject: Schema.String
      readonly channel: Schema.Literals<readonly ["payload", "query", "headers", "params", "emptyInput"]>
      readonly schema: Schema.Struct<{
        readonly module: Schema.String
        readonly export: Schema.String
        readonly symbolId: Schema.brand<Schema.String, "effx/StableId">
      }>
      readonly others: Schema.$Array<Schema.String>
    }
  >
  readonly ExportName: Schema.TaggedStruct<
    "ExportName",
    {
      readonly subject: Schema.String
      readonly role: Schema.String
      readonly name: Schema.String
      readonly source: Schema.Literals<readonly ["names", "derived"]>
      readonly module: Schema.String
    }
  >
}>

Decision (type alias)

Signature

type Decision = typeof Decision.Type

LiftResult

The complete outcome of lifting one group. Lifting never throws; every problem is a diagnostic here.

Signature

declare const LiftResult: Schema.Struct<{
  readonly group: Schema.String
  readonly collected: Schema.Struct<{
    readonly declarations: Schema.$Array<
      Schema.Struct<{
        readonly id: Schema.String
        readonly kind: Schema.Literals<readonly ["class", "staticMethod", "builder", "model"]>
        readonly module: Schema.String
        readonly export: Schema.String
        readonly member: Schema.optionalKey<Schema.String>
        readonly annotations: Schema.$Array<
          Schema.Struct<{
            readonly name: Schema.String
            readonly args: Schema.$Array<Schema.Codec<AnnotationArg, AnnotationArg, never, never>>
            readonly definition: Schema.optionalKey<
              Schema.Struct<{
                readonly module: Schema.String
                readonly export: Schema.String
                readonly member: Schema.optionalKey<Schema.String>
              }>
            >
          }>
        >
        readonly binding: Schema.optionalKey<Schema.Literal<"external">>
        readonly handlerSignature: Schema.optionalKey<
          Schema.Struct<{
            readonly success: Schema.TaggedUnion<{
              readonly Schema: Schema.TaggedStruct<
                "Schema",
                {
                  readonly ref: Schema.Struct<{
                    readonly module: Schema.String
                    readonly export: Schema.String
                    readonly symbolId: Schema.brand<Schema.String, "effx/StableId">
                  }>
                  readonly httpStatus: Schema.optionalKey<Schema.Int>
                  readonly errorTag: Schema.optionalKey<Schema.String>
                }
              >
              readonly Service: Schema.TaggedStruct<
                "Service",
                {
                  readonly id: Schema.brand<Schema.String, "effx/StableId">
                  readonly symbol: Schema.Struct<{
                    readonly module: Schema.String
                    readonly export: Schema.String
                    readonly member: Schema.optionalKey<Schema.String>
                  }>
                }
              >
              readonly Opaque: Schema.TaggedStruct<"Opaque", { readonly display: Schema.String }>
            }>
            readonly errors: Schema.$Array<
              Schema.TaggedUnion<{
                readonly Schema: Schema.TaggedStruct<
                  "Schema",
                  {
                    readonly ref: Schema.Struct<{
                      readonly module: Schema.String
                      readonly export: Schema.String
                      readonly symbolId: Schema.brand<Schema.String, "effx/StableId">
                    }>
                    readonly httpStatus: Schema.optionalKey<Schema.Int>
                    readonly errorTag: Schema.optionalKey<Schema.String>
                  }
                >
                readonly Service: Schema.TaggedStruct<
                  "Service",
                  {
                    readonly id: Schema.brand<Schema.String, "effx/StableId">
                    readonly symbol: Schema.Struct<{
                      readonly module: Schema.String
                      readonly export: Schema.String
                      readonly member: Schema.optionalKey<Schema.String>
                    }>
                  }
                >
                readonly Opaque: Schema.TaggedStruct<"Opaque", { readonly display: Schema.String }>
              }>
            >
            readonly requirements: Schema.$Array<
              Schema.TaggedUnion<{
                readonly Schema: Schema.TaggedStruct<
                  "Schema",
                  {
                    readonly ref: Schema.Struct<{
                      readonly module: Schema.String
                      readonly export: Schema.String
                      readonly symbolId: Schema.brand<Schema.String, "effx/StableId">
                    }>
                    readonly httpStatus: Schema.optionalKey<Schema.Int>
                    readonly errorTag: Schema.optionalKey<Schema.String>
                  }
                >
                readonly Service: Schema.TaggedStruct<
                  "Service",
                  {
                    readonly id: Schema.brand<Schema.String, "effx/StableId">
                    readonly symbol: Schema.Struct<{
                      readonly module: Schema.String
                      readonly export: Schema.String
                      readonly member: Schema.optionalKey<Schema.String>
                    }>
                  }
                >
                readonly Opaque: Schema.TaggedStruct<"Opaque", { readonly display: Schema.String }>
              }>
            >
          }>
        >
        readonly location: Schema.optionalKey<
          Schema.Struct<{ readonly file: Schema.String; readonly line: Schema.Int; readonly col: Schema.Int }>
        >
      }>
    >
    readonly bindings: Schema.optionalKey<
      Schema.$Array<
        Schema.Struct<{
          readonly group: Schema.Struct<{
            readonly module: Schema.String
            readonly export: Schema.String
            readonly member: Schema.optionalKey<Schema.String>
          }>
          readonly handlers: Schema.Struct<{
            readonly module: Schema.String
            readonly export: Schema.String
            readonly member: Schema.optionalKey<Schema.String>
          }>
          readonly handlersTypeParameters: Schema.$Array<
            Schema.Struct<{
              readonly name: Schema.String
              readonly constraint: Schema.String
              readonly default: Schema.String
              readonly references: Schema.$Array<
                Schema.Struct<{
                  readonly ref: Schema.Struct<{
                    readonly module: Schema.String
                    readonly export: Schema.String
                    readonly member: Schema.optionalKey<Schema.String>
                  }>
                  readonly where: Schema.Literals<readonly ["constraint", "default"]>
                  readonly start: Schema.Finite
                  readonly end: Schema.Finite
                }>
              >
            }>
          >
          readonly guardsTypeParameters: Schema.$Array<
            Schema.Struct<{
              readonly name: Schema.String
              readonly constraint: Schema.String
              readonly default: Schema.String
              readonly references: Schema.$Array<
                Schema.Struct<{
                  readonly ref: Schema.Struct<{
                    readonly module: Schema.String
                    readonly export: Schema.String
                    readonly member: Schema.optionalKey<Schema.String>
                  }>
                  readonly where: Schema.Literals<readonly ["constraint", "default"]>
                  readonly start: Schema.Finite
                  readonly end: Schema.Finite
                }>
              >
            }>
          >
          readonly guards: Schema.optionalKey<
            Schema.Struct<{
              readonly module: Schema.String
              readonly export: Schema.String
              readonly member: Schema.optionalKey<Schema.String>
            }>
          >
          readonly guardFor: Schema.optionalKey<
            Schema.Struct<{
              readonly module: Schema.String
              readonly export: Schema.String
              readonly member: Schema.optionalKey<Schema.String>
            }>
          >
        }>
      >
    >
    readonly diagnostics: Schema.$Array<
      Schema.Struct<{
        readonly code: Schema.String
        readonly severity: Schema.Literals<readonly ["error", "warning", "info"]>
        readonly message: Schema.String
        readonly location: Schema.optionalKey<
          Schema.Struct<{ readonly file: Schema.String; readonly line: Schema.Int; readonly col: Schema.Int }>
        >
        readonly related: Schema.optionalKey<
          Schema.$Array<Schema.suspend<Schema.Codec<Diagnostic, Diagnostic, never, never>>>
        >
      }>
    >
    readonly spreads: Schema.optionalKey<
      Schema.$Array<
        Schema.Struct<{
          readonly declarationId: Schema.String
          readonly operand: Schema.String
          readonly location: Schema.Struct<{
            readonly file: Schema.String
            readonly line: Schema.Int
            readonly col: Schema.Int
          }>
        }>
      >
    >
    readonly project: Schema.optionalKey<
      Schema.Struct<{
        readonly naming: Schema.optionalKey<
          Schema.Struct<{ readonly problemIdentifier: Schema.optionalKey<Schema.String> }>
        >
        readonly target: Schema.Literals<readonly ["effect-4.0"]>
        readonly emit: Schema.Literals<readonly ["contract", "handlers", "all"]>
        readonly strictAccess: Schema.optionalKey<Schema.Boolean>
        readonly allowImportingTsExtensions: Schema.Boolean
        readonly canonicalImportBase: Schema.String
        readonly outputDir: Schema.String
      }>
    >
  }>
  readonly refactors: Schema.$Array<
    Schema.Struct<{
      readonly code: Schema.Literals<readonly ["EFFX3002", "EFFX3003", "EFFX3004"]>
      readonly subject: Schema.String
      readonly file: Schema.String
      readonly sourceSha256: Schema.String
      readonly cause: Schema.Struct<{
        readonly code: Schema.String
        readonly severity: Schema.Literals<readonly ["error", "warning", "info"]>
        readonly message: Schema.String
        readonly location: Schema.optionalKey<
          Schema.Struct<{ readonly file: Schema.String; readonly line: Schema.Int; readonly col: Schema.Int }>
        >
        readonly related: Schema.optionalKey<
          Schema.$Array<Schema.suspend<Schema.Codec<Diagnostic, Diagnostic, never, never>>>
        >
      }>
      readonly edits: Schema.NonEmptyArray<
        Schema.TaggedUnion<{
          readonly InsertExport: Schema.TaggedStruct<
            "InsertExport",
            {
              readonly at: Schema.Struct<{
                readonly offset: Schema.Int
                readonly line: Schema.Int
                readonly col: Schema.Int
              }>
              readonly name: Schema.String
              readonly initializer: Schema.Codec<Term, Term, never, never>
              readonly asConst: Schema.Boolean
            }
          >
          readonly InsertImport: Schema.TaggedStruct<
            "InsertImport",
            {
              readonly at: Schema.Struct<{
                readonly offset: Schema.Int
                readonly line: Schema.Int
                readonly col: Schema.Int
              }>
              readonly ref: Schema.Union<
                readonly [
                  Schema.Struct<{
                    readonly module: Schema.String
                    readonly export: Schema.String
                    readonly symbolId: Schema.brand<Schema.String, "effx/StableId">
                  }>,
                  Schema.Struct<{
                    readonly module: Schema.String
                    readonly export: Schema.String
                    readonly member: Schema.optionalKey<Schema.String>
                  }>
                ]
              >
              readonly local: Schema.String
            }
          >
          readonly Replace: Schema.TaggedStruct<
            "Replace",
            {
              readonly range: Schema.Struct<{
                readonly file: Schema.String
                readonly start: Schema.Struct<{
                  readonly offset: Schema.Int
                  readonly line: Schema.Int
                  readonly col: Schema.Int
                }>
                readonly end: Schema.Struct<{
                  readonly offset: Schema.Int
                  readonly line: Schema.Int
                  readonly col: Schema.Int
                }>
              }>
              readonly replacement: Schema.Codec<Term, Term, never, never>
            }
          >
        }>
      >
      readonly planned: Schema.$Array<
        Schema.Struct<{
          readonly key: Schema.String
          readonly role: Schema.Literals<
            readonly ["params", "query", "headers", "payload", "success", "codes", "responseHeaders"]
          >
          readonly name: Schema.String
          readonly source: Schema.Literals<readonly ["names", "derived"]>
          readonly ref: Schema.Union<
            readonly [
              Schema.Struct<{
                readonly module: Schema.String
                readonly export: Schema.String
                readonly symbolId: Schema.brand<Schema.String, "effx/StableId">
              }>,
              Schema.Struct<{
                readonly module: Schema.String
                readonly export: Schema.String
                readonly member: Schema.optionalKey<Schema.String>
              }>
            ]
          >
        }>
      >
    }>
  >
  readonly decisions: Schema.$Array<
    Schema.TaggedUnion<{
      readonly OperationKind: Schema.TaggedStruct<
        "OperationKind",
        {
          readonly subject: Schema.String
          readonly kind: Schema.Literals<readonly ["Query", "Command"]>
          readonly method: Schema.String
        }
      >
      readonly OperationInput: Schema.TaggedStruct<
        "OperationInput",
        {
          readonly subject: Schema.String
          readonly channel: Schema.Literals<readonly ["payload", "query", "headers", "params", "emptyInput"]>
          readonly schema: Schema.Struct<{
            readonly module: Schema.String
            readonly export: Schema.String
            readonly symbolId: Schema.brand<Schema.String, "effx/StableId">
          }>
          readonly others: Schema.$Array<Schema.String>
        }
      >
      readonly ExportName: Schema.TaggedStruct<
        "ExportName",
        {
          readonly subject: Schema.String
          readonly role: Schema.String
          readonly name: Schema.String
          readonly source: Schema.Literals<readonly ["names", "derived"]>
          readonly module: Schema.String
        }
      >
    }>
  >
  readonly unsupported: Schema.$Array<
    Schema.Struct<{
      readonly subject: Schema.String
      readonly range: Schema.Struct<{
        readonly file: Schema.String
        readonly start: Schema.Struct<{
          readonly offset: Schema.Int
          readonly line: Schema.Int
          readonly col: Schema.Int
        }>
        readonly end: Schema.Struct<{
          readonly offset: Schema.Int
          readonly line: Schema.Int
          readonly col: Schema.Int
        }>
      }>
      readonly primary: Schema.Struct<{
        readonly code: Schema.String
        readonly severity: Schema.Literals<readonly ["error", "warning", "info"]>
        readonly message: Schema.String
        readonly location: Schema.optionalKey<
          Schema.Struct<{ readonly file: Schema.String; readonly line: Schema.Int; readonly col: Schema.Int }>
        >
        readonly related: Schema.optionalKey<
          Schema.$Array<Schema.suspend<Schema.Codec<Diagnostic, Diagnostic, never, never>>>
        >
      }>
    }>
  >
  readonly adapterPrerequisites: Schema.$Array<
    Schema.Struct<{
      readonly rule: Schema.String
      readonly role: Schema.String
      readonly ref: Schema.Struct<{
        readonly module: Schema.String
        readonly export: Schema.String
        readonly member: Schema.optionalKey<Schema.String>
      }>
    }>
  >
  readonly codeReferences: Schema.$Array<
    Schema.Struct<{
      readonly identifier: Schema.String
      readonly codes: Schema.$Array<Schema.String>
      readonly ref: Schema.Struct<{
        readonly module: Schema.String
        readonly export: Schema.String
        readonly member: Schema.optionalKey<Schema.String>
      }>
    }>
  >
  readonly bindings: Schema.$Array<
    Schema.Struct<{
      readonly group: Schema.String
      readonly declared: Schema.$Array<Schema.String>
      readonly bound: Schema.$Array<Schema.String>
      readonly missing: Schema.$Array<Schema.String>
      readonly extra: Schema.$Array<Schema.String>
      readonly registrations: Schema.$Array<
        Schema.Struct<{
          readonly key: Schema.String
          readonly kind: Schema.Literals<readonly ["raw", "normal"]>
          readonly handler: Schema.TaggedUnion<{
            readonly Exported: Schema.TaggedStruct<
              "Exported",
              {
                readonly ref: Schema.Struct<{
                  readonly module: Schema.String
                  readonly export: Schema.String
                  readonly member: Schema.optionalKey<Schema.String>
                }>
              }
            >
            readonly Inline: Schema.TaggedStruct<
              "Inline",
              {
                readonly range: Schema.Struct<{
                  readonly file: Schema.String
                  readonly start: Schema.Struct<{
                    readonly offset: Schema.Int
                    readonly line: Schema.Int
                    readonly col: Schema.Int
                  }>
                  readonly end: Schema.Struct<{
                    readonly offset: Schema.Int
                    readonly line: Schema.Int
                    readonly col: Schema.Int
                  }>
                }>
              }
            >
            readonly Unavailable: Schema.TaggedStruct<
              "Unavailable",
              {
                readonly finding: Schema.Struct<{
                  readonly kind: Schema.Literals<
                    readonly [
                      "spread",
                      "computed-key",
                      "non-literal",
                      "local-reference",
                      "closure",
                      "unresolved",
                      "unsupported-syntax"
                    ]
                  >
                  readonly construct: Schema.String
                  readonly range: Schema.Struct<{
                    readonly file: Schema.String
                    readonly start: Schema.Struct<{
                      readonly offset: Schema.Int
                      readonly line: Schema.Int
                      readonly col: Schema.Int
                    }>
                    readonly end: Schema.Struct<{
                      readonly offset: Schema.Int
                      readonly line: Schema.Int
                      readonly col: Schema.Int
                    }>
                  }>
                  readonly enclosingCall: Schema.optionalKey<
                    Schema.Struct<{
                      readonly callee: Schema.Struct<{
                        readonly module: Schema.String
                        readonly export: Schema.String
                        readonly member: Schema.optionalKey<Schema.String>
                      }>
                    }>
                  >
                }>
              }
            >
          }>
        }>
      >
      readonly authorizeCalls: Schema.$Array<
        Schema.Struct<{
          readonly file: Schema.String
          readonly start: Schema.Struct<{
            readonly offset: Schema.Int
            readonly line: Schema.Int
            readonly col: Schema.Int
          }>
          readonly end: Schema.Struct<{
            readonly offset: Schema.Int
            readonly line: Schema.Int
            readonly col: Schema.Int
          }>
        }>
      >
      readonly verification: Schema.Literal<"UNVERIFIED">
    }>
  >
  readonly diagnostics: Schema.$Array<
    Schema.Struct<{
      readonly code: Schema.String
      readonly severity: Schema.Literals<readonly ["error", "warning", "info"]>
      readonly message: Schema.String
      readonly location: Schema.optionalKey<
        Schema.Struct<{ readonly file: Schema.String; readonly line: Schema.Int; readonly col: Schema.Int }>
      >
      readonly related: Schema.optionalKey<
        Schema.$Array<Schema.suspend<Schema.Codec<Diagnostic, Diagnostic, never, never>>>
      >
    }>
  >
}>

LiftResult (type alias)

Signature

type LiftResult = typeof LiftResult.Type

NameSource

Where a planned or derived export name came from.

Signature

declare const NameSource: Schema.Literals<readonly ["names", "derived"]>

NameSource (type alias)

Signature

type NameSource = typeof NameSource.Type

One export a refactor introduces and the real reference the suggestion uses for it. key is the key of LiftInput.names it answers to (<group>.<endpointKey>#<role>, <module>#<export>#codes or <module>#<export>#headers), so a pinned name and a derived name are told apart by source alone.

Signature

declare const PlannedExport: Schema.Struct<{
  readonly key: Schema.String
  readonly role: Schema.Literals<
    readonly ["params", "query", "headers", "payload", "success", "codes", "responseHeaders"]
  >
  readonly name: Schema.String
  readonly source: Schema.Literals<readonly ["names", "derived"]>
  readonly ref: Schema.Union<
    readonly [
      Schema.Struct<{
        readonly module: Schema.String
        readonly export: Schema.String
        readonly symbolId: Schema.brand<Schema.String, "effx/StableId">
      }>,
      Schema.Struct<{
        readonly module: Schema.String
        readonly export: Schema.String
        readonly member: Schema.optionalKey<Schema.String>
      }>
    ]
  >
}>

PlannedExport (type alias)

Signature

type PlannedExport = typeof PlannedExport.Type

Refactor

A wire-preserving source refactor (EFFX3002-3004): the registered diagnostic that explains it, the file it edits with the hash of the analyzed text, its typed edits and the exports it plans. The compiler never applies it.

Signature

declare const Refactor: Schema.Struct<{
  readonly code: Schema.Literals<readonly ["EFFX3002", "EFFX3003", "EFFX3004"]>
  readonly subject: Schema.String
  readonly file: Schema.String
  readonly sourceSha256: Schema.String
  readonly cause: Schema.Struct<{
    readonly code: Schema.String
    readonly severity: Schema.Literals<readonly ["error", "warning", "info"]>
    readonly message: Schema.String
    readonly location: Schema.optionalKey<
      Schema.Struct<{ readonly file: Schema.String; readonly line: Schema.Int; readonly col: Schema.Int }>
    >
    readonly related: Schema.optionalKey<
      Schema.$Array<Schema.suspend<Schema.Codec<Diagnostic, Diagnostic, never, never>>>
    >
  }>
  readonly edits: Schema.NonEmptyArray<
    Schema.TaggedUnion<{
      readonly InsertExport: Schema.TaggedStruct<
        "InsertExport",
        {
          readonly at: Schema.Struct<{
            readonly offset: Schema.Int
            readonly line: Schema.Int
            readonly col: Schema.Int
          }>
          readonly name: Schema.String
          readonly initializer: Schema.Codec<Term, Term, never, never>
          readonly asConst: Schema.Boolean
        }
      >
      readonly InsertImport: Schema.TaggedStruct<
        "InsertImport",
        {
          readonly at: Schema.Struct<{
            readonly offset: Schema.Int
            readonly line: Schema.Int
            readonly col: Schema.Int
          }>
          readonly ref: Schema.Union<
            readonly [
              Schema.Struct<{
                readonly module: Schema.String
                readonly export: Schema.String
                readonly symbolId: Schema.brand<Schema.String, "effx/StableId">
              }>,
              Schema.Struct<{
                readonly module: Schema.String
                readonly export: Schema.String
                readonly member: Schema.optionalKey<Schema.String>
              }>
            ]
          >
          readonly local: Schema.String
        }
      >
      readonly Replace: Schema.TaggedStruct<
        "Replace",
        {
          readonly range: Schema.Struct<{
            readonly file: Schema.String
            readonly start: Schema.Struct<{
              readonly offset: Schema.Int
              readonly line: Schema.Int
              readonly col: Schema.Int
            }>
            readonly end: Schema.Struct<{
              readonly offset: Schema.Int
              readonly line: Schema.Int
              readonly col: Schema.Int
            }>
          }>
          readonly replacement: Schema.Codec<Term, Term, never, never>
        }
      >
    }>
  >
  readonly planned: Schema.$Array<
    Schema.Struct<{
      readonly key: Schema.String
      readonly role: Schema.Literals<
        readonly ["params", "query", "headers", "payload", "success", "codes", "responseHeaders"]
      >
      readonly name: Schema.String
      readonly source: Schema.Literals<readonly ["names", "derived"]>
      readonly ref: Schema.Union<
        readonly [
          Schema.Struct<{
            readonly module: Schema.String
            readonly export: Schema.String
            readonly symbolId: Schema.brand<Schema.String, "effx/StableId">
          }>,
          Schema.Struct<{
            readonly module: Schema.String
            readonly export: Schema.String
            readonly member: Schema.optionalKey<Schema.String>
          }>
        ]
      >
    }>
  >
}>

Refactor (type alias)

Signature

type Refactor = typeof Refactor.Type

SourceEdit

One typed edit of one source file, with the coordinates and initializer data the CLI needs. Positions are offsets into the exact text whose hash the owning refactor records. Terms are printed against the file's own import bindings by the patch renderer; nothing here is a source string built from unknown payload.

Signature

declare const SourceEdit: Schema.TaggedUnion<{
  readonly InsertExport: Schema.TaggedStruct<
    "InsertExport",
    {
      readonly at: Schema.Struct<{ readonly offset: Schema.Int; readonly line: Schema.Int; readonly col: Schema.Int }>
      readonly name: Schema.String
      readonly initializer: Schema.Codec<Term, Term, never, never>
      readonly asConst: Schema.Boolean
    }
  >
  readonly InsertImport: Schema.TaggedStruct<
    "InsertImport",
    {
      readonly at: Schema.Struct<{ readonly offset: Schema.Int; readonly line: Schema.Int; readonly col: Schema.Int }>
      readonly ref: Schema.Union<
        readonly [
          Schema.Struct<{
            readonly module: Schema.String
            readonly export: Schema.String
            readonly symbolId: Schema.brand<Schema.String, "effx/StableId">
          }>,
          Schema.Struct<{
            readonly module: Schema.String
            readonly export: Schema.String
            readonly member: Schema.optionalKey<Schema.String>
          }>
        ]
      >
      readonly local: Schema.String
    }
  >
  readonly Replace: Schema.TaggedStruct<
    "Replace",
    {
      readonly range: Schema.Struct<{
        readonly file: Schema.String
        readonly start: Schema.Struct<{
          readonly offset: Schema.Int
          readonly line: Schema.Int
          readonly col: Schema.Int
        }>
        readonly end: Schema.Struct<{
          readonly offset: Schema.Int
          readonly line: Schema.Int
          readonly col: Schema.Int
        }>
      }>
      readonly replacement: Schema.Codec<Term, Term, never, never>
    }
  >
}>

SourceEdit (type alias)

Signature

type SourceEdit = typeof SourceEdit.Type

result

result.ts overview

Exports Grouped by Category

utils

AdapterPrerequisite

AdapterPrerequisite (type alias)

BindingReport

BindingReport (type alias)

CodeReference

CodeReference (type alias)

Decision

Decision (type alias)

LiftResult

LiftResult (type alias)

NameSource

NameSource (type alias)

PlannedExport

PlannedExport (type alias)

Refactor

Refactor (type alias)

SourceEdit

SourceEdit (type alias)

On this page

result

result.ts overviewCopy Anchor Link

Exports Grouped by CategoryCopy Anchor Link

utilsCopy Anchor Link

AdapterPrerequisiteCopy Anchor Link

AdapterPrerequisite (type alias)Copy Anchor Link

BindingReportCopy Anchor Link

BindingReport (type alias)Copy Anchor Link

CodeReferenceCopy Anchor Link

CodeReference (type alias)Copy Anchor Link

DecisionCopy Anchor Link

Decision (type alias)Copy Anchor Link

LiftResultCopy Anchor Link

LiftResult (type alias)Copy Anchor Link

NameSourceCopy Anchor Link

NameSource (type alias)Copy Anchor Link

PlannedExportCopy Anchor Link

PlannedExport (type alias)Copy Anchor Link

RefactorCopy Anchor Link

Refactor (type alias)Copy Anchor Link

SourceEditCopy Anchor Link

SourceEdit (type alias)Copy Anchor Link

On this page

result.ts overview

Exports Grouped by Category

utils

AdapterPrerequisite

AdapterPrerequisite (type alias)

BindingReport

BindingReport (type alias)

CodeReference

CodeReference (type alias)

Decision

Decision (type alias)

LiftResult

LiftResult (type alias)

NameSource

NameSource (type alias)

PlannedExport

PlannedExport (type alias)

Refactor

Refactor (type alias)

SourceEdit

SourceEdit (type alias)