@sanity/cli 5.9.0-next.8 → 6.0.0-alpha.11

package/dist/index.d.ts

@@ -0,0 +1,2326 @@
+import {CliConfig} from '@sanity/cli-core'
+import {loadEnv} from 'vite'
+import {NodePath} from '@babel/core'
+import {NodePath as NodePath_2} from '@babel/traverse'
+import {SanityClient} from '@sanity/client'
+import {Scope} from '@babel/traverse'
+import * as t from '@babel/types'
+import {UserViteConfig} from '@sanity/cli-core'
+import {z} from 'zod'
+
+declare type AliasingEffect =
+  | {
+      kind: 'Freeze'
+      value: Place
+      reason: ValueReason
+    }
+  | {
+      kind: 'Mutate'
+      value: Place
+      reason?: MutationReason | null
+    }
+  | {
+      kind: 'MutateConditionally'
+      value: Place
+    }
+  | {
+      kind: 'MutateTransitive'
+      value: Place
+    }
+  | {
+      kind: 'MutateTransitiveConditionally'
+      value: Place
+    }
+  | {
+      kind: 'Capture'
+      from: Place
+      into: Place
+    }
+  | {
+      kind: 'Alias'
+      from: Place
+      into: Place
+    }
+  | {
+      kind: 'MaybeAlias'
+      from: Place
+      into: Place
+    }
+  | {
+      kind: 'Assign'
+      from: Place
+      into: Place
+    }
+  | {
+      kind: 'Create'
+      into: Place
+      value: ValueKind
+      reason: ValueReason
+    }
+  | {
+      kind: 'CreateFrom'
+      from: Place
+      into: Place
+    }
+  | {
+      kind: 'ImmutableCapture'
+      from: Place
+      into: Place
+    }
+  | {
+      kind: 'Apply'
+      receiver: Place
+      function: Place
+      mutatesFunction: boolean
+      args: Array<Place | SpreadPattern | Hole>
+      into: Place
+      signature: FunctionSignature | null
+      loc: SourceLocation
+    }
+  | {
+      kind: 'CreateFunction'
+      captures: Array<Place>
+      function: FunctionExpression | ObjectMethod
+      into: Place
+    }
+  | {
+      kind: 'MutateFrozen'
+      place: Place
+      error: CompilerDiagnostic
+    }
+  | {
+      kind: 'MutateGlobal'
+      place: Place
+      error: CompilerDiagnostic
+    }
+  | {
+      kind: 'Impure'
+      place: Place
+      error: CompilerDiagnostic
+    }
+  | {
+      kind: 'Render'
+      place: Place
+    }
+
+declare type AliasingSignature = {
+  receiver: IdentifierId
+  params: Array<IdentifierId>
+  rest: IdentifierId | null
+  returns: IdentifierId
+  effects: Array<AliasingEffect>
+  temporaries: Array<Place>
+}
+
+declare type ArrayExpression = {
+  kind: 'ArrayExpression'
+  elements: Array<Place | SpreadPattern | Hole>
+  loc: SourceLocation
+}
+
+declare type ArrayPattern = {
+  kind: 'ArrayPattern'
+  items: Array<Place | SpreadPattern | Hole>
+}
+
+declare type AutoDepsDecorationsEvent = {
+  kind: 'AutoDepsDecorations'
+  fnLoc: t.SourceLocation
+  decorations: Array<t.SourceLocation>
+}
+
+declare type AutoDepsEligibleEvent = {
+  kind: 'AutoDepsEligible'
+  fnLoc: t.SourceLocation
+  depArrayLoc: t.SourceLocation
+}
+
+declare type BabelFn =
+  | NodePath<t.FunctionDeclaration>
+  | NodePath<t.FunctionExpression>
+  | NodePath<t.ArrowFunctionExpression>
+
+declare type BasicBlock = {
+  kind: BlockKind
+  id: BlockId
+  instructions: Array<Instruction>
+  terminal: Terminal
+  preds: Set<BlockId>
+  phis: Set<Phi>
+}
+
+declare type BlockId = number & {
+  [opaqueBlockId]: 'BlockId'
+}
+
+declare type BlockKind = 'block' | 'value' | 'loop' | 'sequence' | 'catch'
+
+declare type BranchTerminal = {
+  kind: 'branch'
+  test: Place
+  consequent: BlockId
+  alternate: BlockId
+  id: InstructionId
+  loc: SourceLocation
+  fallthrough: BlockId
+}
+
+declare type BuiltinTag = {
+  kind: 'BuiltinTag'
+  name: string
+  loc: SourceLocation
+}
+
+declare type BuiltInType = PrimitiveType | FunctionType | ObjectType
+
+declare type CallExpression = {
+  kind: 'CallExpression'
+  callee: Place
+  args: Array<Place | SpreadPattern>
+  loc: SourceLocation
+  typeArguments?: Array<t.FlowType>
+}
+
+declare type Case = {
+  test: Place | null
+  block: BlockId
+}
+
+declare type CliClientGetter = ((options?: CliClientOptions) => SanityClient) & {
+  /**
+   * @deprecated This is only for INTERNAL use, and should not be relied upon outside of official Sanity modules
+   * @returns A token to use when constructing a client without a `token` explicitly defined, or undefined
+   * @internal
+   */
+  __internal__getToken: () => string | undefined
+}
+
+/**
+ * @public
+ */
+export declare interface CliClientOptions {
+  apiVersion?: string
+  cwd?: string
+  dataset?: string
+  projectId?: string
+  token?: string
+  useCdn?: boolean
+}
+
+declare type CodegenFunction = {
+  type: 'CodegenFunction'
+  id: t.Identifier | null
+  nameHint: string | null
+  params: t.FunctionDeclaration['params']
+  body: t.BlockStatement
+  generator: boolean
+  async: boolean
+  loc: SourceLocation
+  memoSlotsUsed: number
+  memoBlocks: number
+  memoValues: number
+  prunedMemoBlocks: number
+  prunedMemoValues: number
+  outlined: Array<{
+    fn: CodegenFunction
+    type: ReactFunctionType | null
+  }>
+  hasInferredEffect: boolean
+  inferredEffectLocations: Set<SourceLocation>
+  hasFireRewrite: boolean
+}
+
+declare type CompilationMode = z.infer<typeof CompilationModeSchema>
+
+declare const CompilationModeSchema: z.ZodEnum<{
+  syntax: 'syntax'
+  infer: 'infer'
+  annotation: 'annotation'
+  all: 'all'
+}>
+
+declare type CompileDiagnosticEvent = {
+  kind: 'CompileDiagnostic'
+  fnLoc: t.SourceLocation | null
+  detail: Omit<Omit<CompilerErrorDetailOptions, 'severity'>, 'suggestions'>
+}
+
+declare type CompileErrorEvent = {
+  kind: 'CompileError'
+  fnLoc: t.SourceLocation | null
+  detail: CompilerErrorDetail | CompilerDiagnostic
+}
+
+declare class CompilerDiagnostic {
+  options: CompilerDiagnosticOptions
+  constructor(options: CompilerDiagnosticOptions)
+  static create(options: Omit<CompilerDiagnosticOptions, 'details'>): CompilerDiagnostic
+  get reason(): CompilerDiagnosticOptions['reason']
+  get description(): CompilerDiagnosticOptions['description']
+  get severity(): ErrorSeverity
+  get suggestions(): CompilerDiagnosticOptions['suggestions']
+  get category(): ErrorCategory
+  withDetails(...details: Array<CompilerDiagnosticDetail>): CompilerDiagnostic
+  primaryLocation(): SourceLocation | null
+  printErrorMessage(source: string, options: PrintErrorMessageOptions): string
+  toString(): string
+}
+
+declare type CompilerDiagnosticDetail =
+  | {
+      kind: 'error'
+      loc: SourceLocation | null
+      message: string | null
+    }
+  | {
+      kind: 'hint'
+      message: string
+    }
+
+declare type CompilerDiagnosticOptions = {
+  category: ErrorCategory
+  reason: string
+  description: string | null
+  details: Array<CompilerDiagnosticDetail>
+  suggestions?: Array<CompilerSuggestion> | null | undefined
+}
+
+declare class CompilerError extends Error {
+  details: Array<CompilerErrorDetail | CompilerDiagnostic>
+  disabledDetails: Array<CompilerErrorDetail | CompilerDiagnostic>
+  printedMessage: string | null
+  static invariant(
+    condition: unknown,
+    options: Omit<CompilerDiagnosticOptions, 'category'>,
+  ): asserts condition
+  static throwDiagnostic(options: CompilerDiagnosticOptions): never
+  static throwTodo(options: Omit<CompilerErrorDetailOptions, 'category'>): never
+  static throwInvalidJS(options: Omit<CompilerErrorDetailOptions, 'category'>): never
+  static throwInvalidReact(options: CompilerErrorDetailOptions): never
+  static throwInvalidConfig(options: Omit<CompilerErrorDetailOptions, 'category'>): never
+  static throw(options: CompilerErrorDetailOptions): never
+  constructor(...args: Array<any>)
+  get message(): string
+  set message(_message: string)
+  toString(): string
+  withPrintedMessage(source: string, options: PrintErrorMessageOptions): CompilerError
+  printErrorMessage(source: string, options: PrintErrorMessageOptions): string
+  merge(other: CompilerError): void
+  pushDiagnostic(diagnostic: CompilerDiagnostic): void
+  push(options: CompilerErrorDetailOptions): CompilerErrorDetail
+  pushErrorDetail(detail: CompilerErrorDetail): CompilerErrorDetail
+  hasAnyErrors(): boolean
+  asResult(): Result<void, CompilerError>
+  hasErrors(): boolean
+  hasWarning(): boolean
+  hasHints(): boolean
+}
+
+declare class CompilerErrorDetail {
+  options: CompilerErrorDetailOptions
+  constructor(options: CompilerErrorDetailOptions)
+  get reason(): CompilerErrorDetailOptions['reason']
+  get description(): CompilerErrorDetailOptions['description']
+  get severity(): ErrorSeverity
+  get loc(): CompilerErrorDetailOptions['loc']
+  get suggestions(): CompilerErrorDetailOptions['suggestions']
+  get category(): ErrorCategory
+  primaryLocation(): SourceLocation | null
+  printErrorMessage(source: string, options: PrintErrorMessageOptions): string
+  toString(): string
+}
+
+declare type CompilerErrorDetailOptions = {
+  category: ErrorCategory
+  reason: string
+  description?: string | null | undefined
+  loc: SourceLocation | null
+  suggestions?: Array<CompilerSuggestion> | null | undefined
+}
+
+declare type CompilerMode = 'all_features' | 'no_inferred_memo'
+
+declare type CompilerPipelineValue =
+  | {
+      kind: 'ast'
+      name: string
+      value: CodegenFunction
+    }
+  | {
+      kind: 'hir'
+      name: string
+      value: HIRFunction
+    }
+  | {
+      kind: 'reactive'
+      name: string
+      value: ReactiveFunction
+    }
+  | {
+      kind: 'debug'
+      name: string
+      value: string
+    }
+
+declare type CompilerReactTarget = z.infer<typeof CompilerReactTargetSchema>
+
+declare const CompilerReactTargetSchema: z.ZodUnion<
+  readonly [
+    z.ZodLiteral<'17'>,
+    z.ZodLiteral<'18'>,
+    z.ZodLiteral<'19'>,
+    z.ZodObject<
+      {
+        kind: z.ZodLiteral<'donotuse_meta_internal'>
+        runtimeModule: z.ZodDefault<z.ZodString>
+      },
+      z.core.$strip
+    >,
+  ]
+>
+
+declare type CompilerSuggestion =
+  | {
+      op:
+        | CompilerSuggestionOperation.InsertAfter
+        | CompilerSuggestionOperation.InsertBefore
+        | CompilerSuggestionOperation.Replace
+      range: [number, number]
+      description: string
+      text: string
+    }
+  | {
+      op: CompilerSuggestionOperation.Remove
+      range: [number, number]
+      description: string
+    }
+
+declare enum CompilerSuggestionOperation {
+  InsertBefore = 0,
+  InsertAfter = 1,
+  Remove = 2,
+  Replace = 3,
+}
+
+declare type CompileSkipEvent = {
+  kind: 'CompileSkip'
+  fnLoc: t.SourceLocation | null
+  reason: string
+  loc: t.SourceLocation | null
+}
+
+declare type CompileSuccessEvent = {
+  kind: 'CompileSuccess'
+  fnLoc: t.SourceLocation | null
+  fnName: string | null
+  memoSlots: number
+  memoBlocks: number
+  memoValues: number
+  prunedMemoBlocks: number
+  prunedMemoValues: number
+}
+
+declare type ComponentType<T> = {
+  kind: 'Component'
+  props: Map<string, T>
+  children: null | T
+}
+
+declare type ConcreteType<T> =
+  | {
+      kind: 'Enum'
+    }
+  | {
+      kind: 'Mixed'
+    }
+  | {
+      kind: 'Number'
+    }
+  | {
+      kind: 'String'
+    }
+  | {
+      kind: 'Boolean'
+    }
+  | {
+      kind: 'Void'
+    }
+  | {
+      kind: 'Nullable'
+      type: T
+    }
+  | {
+      kind: 'Array'
+      element: T
+    }
+  | {
+      kind: 'Set'
+      element: T
+    }
+  | {
+      kind: 'Map'
+      key: T
+      value: T
+    }
+  | {
+      kind: 'Function'
+      typeParameters: null | Array<TypeParameter<T>>
+      params: Array<T>
+      returnType: T
+    }
+  | ComponentType<T>
+  | {
+      kind: 'Generic'
+      id: TypeParameterId
+      bound: T
+    }
+  | {
+      kind: 'Object'
+      id: NominalId
+      members: Map<string, ResolvedType>
+    }
+  | {
+      kind: 'Tuple'
+      id: NominalId
+      members: Array<T>
+    }
+  | {
+      kind: 'Structural'
+      id: LinearId
+    }
+  | {
+      kind: 'Union'
+      members: Array<T>
+    }
+  | {
+      kind: 'Instance'
+      name: string
+      members: Map<string, ResolvedType>
+    }
+
+/**
+ * @deprecated Use `defineCliConfig` instead
+ * @public
+ */
+export declare function createCliConfig(config: CliConfig): {
+  api?:
+    | {
+        dataset?: string | undefined
+        projectId?: string | undefined
+      }
+    | undefined
+  app?:
+    | {
+        entry?: string | undefined
+        icon?: string | undefined
+        id?: string | undefined
+        organizationId?: string | undefined
+        title?: string | undefined
+      }
+    | undefined
+  autoUpdates?: boolean | undefined
+  deployment?:
+    | {
+        appId?: string | undefined
+        autoUpdates?: boolean | undefined
+      }
+    | undefined
+  graphql?:
+    | {
+        filterSuffix?: string | undefined
+        generation?: 'gen1' | 'gen2' | 'gen3' | undefined
+        id?: string | undefined
+        nonNullDocumentFields?: boolean | undefined
+        playground?: boolean | undefined
+        source?: string | undefined
+        tag?: string | undefined
+        workspace?: string | undefined
+      }[]
+    | undefined
+  mediaLibrary?:
+    | {
+        aspectsPath?: string | undefined
+      }
+    | undefined
+  project?:
+    | {
+        basePath?: string | undefined
+      }
+    | undefined
+  reactCompiler?:
+    | Partial<{
+        environment: Partial<EnvironmentConfig>
+        logger: Logger | null
+        gating: ExternalFunction | null
+        dynamicGating: {
+          source: string
+        } | null
+        panicThreshold: 'none' | 'all_errors' | 'critical_errors'
+        noEmit: boolean
+        compilationMode: 'syntax' | 'infer' | 'annotation' | 'all'
+        eslintSuppressionRules: Array<string> | null | undefined
+        flowSuppressions: boolean
+        ignoreUseNoForget: boolean
+        customOptOutDirectives: string[] | null
+        sources: Array<string> | ((filename: string) => boolean) | null
+        enableReanimatedCheck: boolean
+        target:
+          | '17'
+          | '18'
+          | '19'
+          | {
+              kind: 'donotuse_meta_internal'
+              runtimeModule: string
+            }
+      }>
+    | undefined
+  reactStrictMode?: boolean | undefined
+  server?:
+    | {
+        hostname?: string | undefined
+        port?: number | undefined
+      }
+    | undefined
+  studioHost?: string | undefined
+  vite?: UserViteConfig | undefined
+  typegen?:
+    | {
+        formatGeneratedCode: boolean
+        generates: string
+        overloadClientMethods: boolean
+        path: string | string[]
+        schema: string
+      }
+    | undefined
+}
+
+declare type CustomOptOutDirective = z.infer<typeof CustomOptOutDirectiveSchema>
+
+declare const CustomOptOutDirectiveSchema: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>
+
+declare type DeclarationId = number & {
+  [opageDeclarationId]: 'DeclarationId'
+}
+
+/** @beta */
+export declare function defineCliConfig(config: CliConfig): CliConfig
+
+declare type DependencyPath = Array<DependencyPathEntry>
+
+declare type DependencyPathEntry = {
+  property: PropertyLiteral
+  optional: boolean
+}
+
+declare type Destructure = {
+  kind: 'Destructure'
+  lvalue: LValuePattern
+  value: Place
+  loc: SourceLocation
+}
+
+declare type DoWhileTerminal = {
+  kind: 'do-while'
+  loop: BlockId
+  test: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type DynamicGatingOptions = z.infer<typeof DynamicGatingOptionsSchema>
+
+declare const DynamicGatingOptionsSchema: z.ZodObject<
+  {
+    source: z.ZodString
+  },
+  z.core.$strip
+>
+
+declare enum Effect {
+  Unknown = '<unknown>',
+  Freeze = 'freeze',
+  Read = 'read',
+  Capture = 'capture',
+  ConditionallyMutateIterator = 'mutate-iterator?',
+  ConditionallyMutate = 'mutate?',
+  Mutate = 'mutate',
+  Store = 'store',
+}
+
+declare class Environment {
+  #private
+  logger: Logger | null
+  filename: string | null
+  code: string | null
+  config: EnvironmentConfig
+  fnType: ReactFunctionType
+  compilerMode: CompilerMode
+  programContext: ProgramContext
+  hasFireRewrite: boolean
+  hasInferredEffect: boolean
+  inferredEffectLocations: Set<SourceLocation>
+  parentFunction: NodePath_2<t.Function>
+  constructor(
+    scope: Scope,
+    fnType: ReactFunctionType,
+    compilerMode: CompilerMode,
+    config: EnvironmentConfig,
+    contextIdentifiers: Set<t.Identifier>,
+    parentFunction: NodePath_2<t.Function>,
+    logger: Logger | null,
+    filename: string | null,
+    code: string | null,
+    programContext: ProgramContext,
+  )
+  get typeContext(): FlowTypeEnv
+  get isInferredMemoEnabled(): boolean
+  get nextIdentifierId(): IdentifierId
+  get nextBlockId(): BlockId
+  get nextScopeId(): ScopeId
+  get scope(): Scope
+  logErrors(errors: Result<void, CompilerError>): void
+  isContextIdentifier(node: t.Identifier): boolean
+  isHoistedIdentifier(node: t.Identifier): boolean
+  generateGloballyUniqueIdentifierName(name: string | null): ValidatedIdentifier
+  outlineFunction(fn: HIRFunction, type: ReactFunctionType | null): void
+  getOutlinedFunctions(): Array<{
+    fn: HIRFunction
+    type: ReactFunctionType | null
+  }>
+  getGlobalDeclaration(binding: NonLocalBinding, loc: SourceLocation): Global_2 | null
+  static knownReactModules: ReadonlyArray<string>
+  getFallthroughPropertyType(receiver: Type, _property: Type): BuiltInType | PolyType | null
+  getPropertyType(receiver: Type, property: string | number): BuiltInType | PolyType | null
+  getFunctionSignature(type: FunctionType): FunctionSignature | null
+  addHoistedIdentifier(node: t.Identifier): void
+}
+
+declare type EnvironmentConfig = z.infer<typeof EnvironmentConfigSchema>
+
+declare const EnvironmentConfigSchema: z.ZodObject<
+  {
+    customHooks: z.ZodDefault<
+      z.ZodMap<
+        z.ZodString,
+        z.ZodObject<
+          {
+            effectKind: z.ZodEnum<typeof Effect>
+            valueKind: z.ZodEnum<typeof ValueKind>
+            noAlias: z.ZodDefault<z.ZodBoolean>
+            transitiveMixedData: z.ZodDefault<z.ZodBoolean>
+          },
+          z.core.$strip
+        >
+      >
+    >
+    moduleTypeProvider: z.ZodDefault<z.ZodNullable<z.ZodAny>>
+    customMacros: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodArray<
+          z.ZodUnion<
+            readonly [
+              z.ZodString,
+              z.ZodTuple<
+                [
+                  z.ZodString,
+                  z.ZodArray<
+                    z.ZodUnion<
+                      readonly [
+                        z.ZodObject<
+                          {
+                            type: z.ZodLiteral<'wildcard'>
+                          },
+                          z.core.$strip
+                        >,
+                        z.ZodObject<
+                          {
+                            type: z.ZodLiteral<'name'>
+                            name: z.ZodString
+                          },
+                          z.core.$strip
+                        >,
+                      ]
+                    >
+                  >,
+                ],
+                null
+              >,
+            ]
+          >
+        >
+      >
+    >
+    enableResetCacheOnSourceFileChanges: z.ZodDefault<z.ZodNullable<z.ZodBoolean>>
+    enablePreserveExistingMemoizationGuarantees: z.ZodDefault<z.ZodBoolean>
+    validatePreserveExistingMemoizationGuarantees: z.ZodDefault<z.ZodBoolean>
+    enablePreserveExistingManualUseMemo: z.ZodDefault<z.ZodBoolean>
+    enableForest: z.ZodDefault<z.ZodBoolean>
+    enableUseTypeAnnotations: z.ZodDefault<z.ZodBoolean>
+    flowTypeProvider: z.ZodDefault<z.ZodNullable<z.ZodAny>>
+    enableOptionalDependencies: z.ZodDefault<z.ZodBoolean>
+    enableFire: z.ZodDefault<z.ZodBoolean>
+    enableNameAnonymousFunctions: z.ZodDefault<z.ZodBoolean>
+    inferEffectDependencies: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodArray<
+          z.ZodObject<
+            {
+              function: z.ZodObject<
+                {
+                  source: z.ZodString
+                  importSpecifierName: z.ZodString
+                },
+                z.core.$strip
+              >
+              autodepsIndex: z.ZodNumber
+            },
+            z.core.$strip
+          >
+        >
+      >
+    >
+    inlineJsxTransform: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            elementSymbol: z.ZodUnion<
+              readonly [z.ZodLiteral<'react.element'>, z.ZodLiteral<'react.transitional.element'>]
+            >
+            globalDevVar: z.ZodString
+          },
+          z.core.$strip
+        >
+      >
+    >
+    validateHooksUsage: z.ZodDefault<z.ZodBoolean>
+    validateRefAccessDuringRender: z.ZodDefault<z.ZodBoolean>
+    validateNoSetStateInRender: z.ZodDefault<z.ZodBoolean>
+    validateNoSetStateInEffects: z.ZodDefault<z.ZodBoolean>
+    validateNoDerivedComputationsInEffects: z.ZodDefault<z.ZodBoolean>
+    validateNoJSXInTryStatements: z.ZodDefault<z.ZodBoolean>
+    validateStaticComponents: z.ZodDefault<z.ZodBoolean>
+    validateMemoizedEffectDependencies: z.ZodDefault<z.ZodBoolean>
+    validateNoCapitalizedCalls: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>
+    validateBlocklistedImports: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString>>>
+    validateNoImpureFunctionsInRender: z.ZodDefault<z.ZodBoolean>
+    validateNoFreezingKnownMutableFunctions: z.ZodDefault<z.ZodBoolean>
+    enableAssumeHooksFollowRulesOfReact: z.ZodDefault<z.ZodBoolean>
+    enableTransitivelyFreezeFunctionExpressions: z.ZodDefault<z.ZodBoolean>
+    enableEmitFreeze: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            source: z.ZodString
+            importSpecifierName: z.ZodString
+          },
+          z.core.$strip
+        >
+      >
+    >
+    enableEmitHookGuards: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            source: z.ZodString
+            importSpecifierName: z.ZodString
+          },
+          z.core.$strip
+        >
+      >
+    >
+    enableInstructionReordering: z.ZodDefault<z.ZodBoolean>
+    enableFunctionOutlining: z.ZodDefault<z.ZodBoolean>
+    enableJsxOutlining: z.ZodDefault<z.ZodBoolean>
+    enableEmitInstrumentForget: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            fn: z.ZodObject<
+              {
+                source: z.ZodString
+                importSpecifierName: z.ZodString
+              },
+              z.core.$strip
+            >
+            gating: z.ZodNullable<
+              z.ZodObject<
+                {
+                  source: z.ZodString
+                  importSpecifierName: z.ZodString
+                },
+                z.core.$strip
+              >
+            >
+            globalGating: z.ZodNullable<z.ZodString>
+          },
+          z.core.$strip
+        >
+      >
+    >
+    assertValidMutableRanges: z.ZodDefault<z.ZodBoolean>
+    enableChangeVariableCodegen: z.ZodDefault<z.ZodBoolean>
+    enableMemoizationComments: z.ZodDefault<z.ZodBoolean>
+    throwUnknownException__testonly: z.ZodDefault<z.ZodBoolean>
+    enableTreatFunctionDepsAsConditional: z.ZodDefault<z.ZodBoolean>
+    disableMemoizationForDebugging: z.ZodDefault<z.ZodBoolean>
+    enableChangeDetectionForDebugging: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            source: z.ZodString
+            importSpecifierName: z.ZodString
+          },
+          z.core.$strip
+        >
+      >
+    >
+    enableCustomTypeDefinitionForReanimated: z.ZodDefault<z.ZodBoolean>
+    hookPattern: z.ZodDefault<z.ZodNullable<z.ZodString>>
+    enableTreatRefLikeIdentifiersAsRefs: z.ZodDefault<z.ZodBoolean>
+    enableTreatSetIdentifiersAsStateSetters: z.ZodDefault<z.ZodBoolean>
+    lowerContextAccess: z.ZodDefault<
+      z.ZodNullable<
+        z.ZodObject<
+          {
+            source: z.ZodString
+            importSpecifierName: z.ZodString
+          },
+          z.core.$strip
+        >
+      >
+    >
+    validateNoVoidUseMemo: z.ZodDefault<z.ZodBoolean>
+    validateNoDynamicallyCreatedComponentsOrHooks: z.ZodDefault<z.ZodBoolean>
+    enableAllowSetStateFromRefsInEffects: z.ZodDefault<z.ZodBoolean>
+  },
+  z.core.$strip
+>
+
+declare class ErrImpl<E> implements Result<never, E> {
+  #private
+  constructor(val: E)
+  map<U>(_fn: (val: never) => U): Result<U, E>
+  mapErr<F>(fn: (val: E) => F): Result<never, F>
+  mapOr<U>(fallback: U, _fn: (val: never) => U): U
+  mapOrElse<U>(fallback: () => U, _fn: (val: never) => U): U
+  andThen<U>(_fn: (val: never) => Result<U, E>): Result<U, E>
+  and<U>(_res: Result<U, E>): Result<U, E>
+  or(res: Result<never, E>): Result<never, E>
+  orElse<F>(fn: (val: E) => ErrImpl<F>): Result<never, F>
+  isOk(): this is OkImpl<never>
+  isErr(): this is ErrImpl<E>
+  expect(msg: string): never
+  expectErr(_msg: string): E
+  unwrap(): never
+  unwrapOr<T>(fallback: T): T
+  unwrapOrElse<T>(fallback: (val: E) => T): T
+  unwrapErr(): E
+}
+
+declare enum ErrorCategory {
+  Hooks = 'Hooks',
+  CapitalizedCalls = 'CapitalizedCalls',
+  StaticComponents = 'StaticComponents',
+  UseMemo = 'UseMemo',
+  Factories = 'Factories',
+  PreserveManualMemo = 'PreserveManualMemo',
+  IncompatibleLibrary = 'IncompatibleLibrary',
+  Immutability = 'Immutability',
+  Globals = 'Globals',
+  Refs = 'Refs',
+  EffectDependencies = 'EffectDependencies',
+  EffectSetState = 'EffectSetState',
+  EffectDerivationsOfState = 'EffectDerivationsOfState',
+  ErrorBoundaries = 'ErrorBoundaries',
+  Purity = 'Purity',
+  RenderSetState = 'RenderSetState',
+  Invariant = 'Invariant',
+  Todo = 'Todo',
+  Syntax = 'Syntax',
+  UnsupportedSyntax = 'UnsupportedSyntax',
+  Config = 'Config',
+  Gating = 'Gating',
+  Suppression = 'Suppression',
+  AutomaticEffectDependencies = 'AutomaticEffectDependencies',
+  Fire = 'Fire',
+  FBT = 'FBT',
+}
+
+declare enum ErrorSeverity {
+  Error = 'Error',
+  Warning = 'Warning',
+  Hint = 'Hint',
+  Off = 'Off',
+}
+
+declare type ExternalFunction = z.infer<typeof ExternalFunctionSchema>
+
+declare const ExternalFunctionSchema: z.ZodObject<
+  {
+    source: z.ZodString
+    importSpecifierName: z.ZodString
+  },
+  z.core.$strip
+>
+
+declare type FinishMemoize = {
+  kind: 'FinishMemoize'
+  manualMemoId: number
+  decl: Place
+  pruned?: true
+  loc: SourceLocation
+}
+
+declare class FlowTypeEnv implements ITypeEnv {
+  #private
+  moduleEnv: Map<string, ResolvedType>
+  init(env: Environment, source: string): void
+  setType(identifier: Identifier, type: ResolvedType): void
+  getType(identifier: Identifier): ResolvedType
+  getTypeOrNull(identifier: Identifier): ResolvedType | null
+  getTypeByLoc(loc: SourceLocation): ResolvedType | null
+  nextNominalId(): NominalId
+  nextTypeParameterId(): TypeParameterId
+  addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void
+  resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null
+  pushGeneric(name: string, generic: TypeParameter<ResolvedType>): void
+  popGeneric(name: string): void
+  getGeneric(name: string): null | TypeParameter<ResolvedType>
+}
+
+declare type ForInTerminal = {
+  kind: 'for-in'
+  loc: SourceLocation
+  init: BlockId
+  loop: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+}
+
+declare type ForOfTerminal = {
+  kind: 'for-of'
+  loc: SourceLocation
+  init: BlockId
+  test: BlockId
+  loop: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+}
+
+declare type ForTerminal = {
+  kind: 'for'
+  loc: SourceLocation
+  init: BlockId
+  test: BlockId
+  update: BlockId | null
+  loop: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+}
+
+declare type FunctionExpression = {
+  kind: 'FunctionExpression'
+  name: ValidIdentifierName | null
+  nameHint: string | null
+  loweredFunc: LoweredFunction
+  type: 'ArrowFunctionExpression' | 'FunctionExpression' | 'FunctionDeclaration'
+  loc: SourceLocation
+}
+
+declare type FunctionSignature = {
+  positionalParams: Array<Effect>
+  restParam: Effect | null
+  returnType: BuiltInType | PolyType
+  returnValueKind: ValueKind
+  returnValueReason?: ValueReason
+  calleeEffect: Effect
+  hookKind: HookKind | null
+  noAlias?: boolean
+  mutableOnlyIfOperandsAreMutable?: boolean
+  impure?: boolean
+  knownIncompatible?: string | null | undefined
+  canonicalName?: string
+  aliasing?: AliasingSignature | null | undefined
+}
+
+declare type FunctionType = {
+  kind: 'Function'
+  shapeId: string | null
+  return: Type
+  isConstructor: boolean
+}
+
+declare const GeneratedSource: unique symbol
+
+/**
+ * @public
+ *
+ * @param options - The options to use for the client.
+ * @returns A configured Sanity API client.
+ */
+export declare const getCliClient: CliClientGetter
+
+declare type Global_2 = BuiltInType | PolyType
+
+declare type GotoTerminal = {
+  kind: 'goto'
+  block: BlockId
+  variant: GotoVariant
+  id: InstructionId
+  loc: SourceLocation
+  fallthrough?: never
+}
+
+declare enum GotoVariant {
+  Break = 'Break',
+  Continue = 'Continue',
+  Try = 'Try',
+}
+
+declare type HIR = {
+  entry: BlockId
+  blocks: Map<BlockId, BasicBlock>
+}
+
+declare type HIRFunction = {
+  loc: SourceLocation
+  id: ValidIdentifierName | null
+  nameHint: string | null
+  fnType: ReactFunctionType
+  env: Environment
+  params: Array<Place | SpreadPattern>
+  returnTypeAnnotation: t.FlowType | t.TSType | null
+  returns: Place
+  context: Array<Place>
+  body: HIR
+  generator: boolean
+  async: boolean
+  directives: Array<string>
+  aliasingEffects: Array<AliasingEffect> | null
+}
+
+declare type Hole = {
+  kind: 'Hole'
+}
+
+declare type HookKind =
+  | 'useContext'
+  | 'useState'
+  | 'useActionState'
+  | 'useReducer'
+  | 'useRef'
+  | 'useEffect'
+  | 'useLayoutEffect'
+  | 'useInsertionEffect'
+  | 'useMemo'
+  | 'useCallback'
+  | 'useTransition'
+  | 'useImperativeHandle'
+  | 'useEffectEvent'
+  | 'Custom'
+
+declare type Identifier = {
+  id: IdentifierId
+  declarationId: DeclarationId
+  name: IdentifierName | null
+  mutableRange: MutableRange
+  scope: ReactiveScope | null
+  type: Type
+  loc: SourceLocation
+}
+
+declare type IdentifierId = number & {
+  [opaqueIdentifierId]: 'IdentifierId'
+}
+
+declare type IdentifierName = ValidatedIdentifier | PromotedIdentifier
+
+declare type IfTerminal = {
+  kind: 'if'
+  test: Place
+  consequent: BlockId
+  alternate: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type Instruction = {
+  id: InstructionId
+  lvalue: Place
+  value: InstructionValue
+  loc: SourceLocation
+  effects: Array<AliasingEffect> | null
+}
+
+declare type InstructionId = number & {
+  [opaqueInstructionId]: 'IdentifierId'
+}
+
+declare enum InstructionKind {
+  Const = 'Const',
+  Let = 'Let',
+  Reassign = 'Reassign',
+  Catch = 'Catch',
+  HoistedConst = 'HoistedConst',
+  HoistedLet = 'HoistedLet',
+  HoistedFunction = 'HoistedFunction',
+  Function = 'Function',
+}
+
+declare type InstructionValue =
+  | LoadLocal
+  | LoadContext
+  | {
+      kind: 'DeclareLocal'
+      lvalue: LValue
+      type: t.FlowType | t.TSType | null
+      loc: SourceLocation
+    }
+  | {
+      kind: 'DeclareContext'
+      lvalue: {
+        kind:
+          | InstructionKind.Let
+          | InstructionKind.HoistedConst
+          | InstructionKind.HoistedLet
+          | InstructionKind.HoistedFunction
+        place: Place
+      }
+      loc: SourceLocation
+    }
+  | StoreLocal
+  | {
+      kind: 'StoreContext'
+      lvalue: {
+        kind:
+          | InstructionKind.Reassign
+          | InstructionKind.Const
+          | InstructionKind.Let
+          | InstructionKind.Function
+        place: Place
+      }
+      value: Place
+      loc: SourceLocation
+    }
+  | Destructure
+  | {
+      kind: 'Primitive'
+      value: number | boolean | string | null | undefined
+      loc: SourceLocation
+    }
+  | JSXText
+  | {
+      kind: 'BinaryExpression'
+      operator: Exclude<t.BinaryExpression['operator'], '|>'>
+      left: Place
+      right: Place
+      loc: SourceLocation
+    }
+  | NewExpression
+  | CallExpression
+  | MethodCall
+  | {
+      kind: 'UnaryExpression'
+      operator: Exclude<t.UnaryExpression['operator'], 'throw' | 'delete'>
+      value: Place
+      loc: SourceLocation
+    }
+  | ({
+      kind: 'TypeCastExpression'
+      value: Place
+      type: Type
+      loc: SourceLocation
+    } & (
+      | {
+          typeAnnotation: t.FlowType
+          typeAnnotationKind: 'cast'
+        }
+      | {
+          typeAnnotation: t.TSType
+          typeAnnotationKind: 'as' | 'satisfies'
+        }
+    ))
+  | JsxExpression
+  | {
+      kind: 'ObjectExpression'
+      properties: Array<ObjectProperty | SpreadPattern>
+      loc: SourceLocation
+    }
+  | ObjectMethod
+  | ArrayExpression
+  | {
+      kind: 'JsxFragment'
+      children: Array<Place>
+      loc: SourceLocation
+    }
+  | {
+      kind: 'RegExpLiteral'
+      pattern: string
+      flags: string
+      loc: SourceLocation
+    }
+  | {
+      kind: 'MetaProperty'
+      meta: string
+      property: string
+      loc: SourceLocation
+    }
+  | {
+      kind: 'PropertyStore'
+      object: Place
+      property: PropertyLiteral
+      value: Place
+      loc: SourceLocation
+    }
+  | PropertyLoad
+  | {
+      kind: 'PropertyDelete'
+      object: Place
+      property: PropertyLiteral
+      loc: SourceLocation
+    }
+  | {
+      kind: 'ComputedStore'
+      object: Place
+      property: Place
+      value: Place
+      loc: SourceLocation
+    }
+  | {
+      kind: 'ComputedLoad'
+      object: Place
+      property: Place
+      loc: SourceLocation
+    }
+  | {
+      kind: 'ComputedDelete'
+      object: Place
+      property: Place
+      loc: SourceLocation
+    }
+  | LoadGlobal
+  | StoreGlobal
+  | FunctionExpression
+  | {
+      kind: 'TaggedTemplateExpression'
+      tag: Place
+      value: {
+        raw: string
+        cooked?: string
+      }
+      loc: SourceLocation
+    }
+  | {
+      kind: 'TemplateLiteral'
+      subexprs: Array<Place>
+      quasis: Array<{
+        raw: string
+        cooked?: string
+      }>
+      loc: SourceLocation
+    }
+  | {
+      kind: 'Await'
+      value: Place
+      loc: SourceLocation
+    }
+  | {
+      kind: 'GetIterator'
+      collection: Place
+      loc: SourceLocation
+    }
+  | {
+      kind: 'IteratorNext'
+      iterator: Place
+      collection: Place
+      loc: SourceLocation
+    }
+  | {
+      kind: 'NextPropertyOf'
+      value: Place
+      loc: SourceLocation
+    }
+  | {
+      kind: 'PrefixUpdate'
+      lvalue: Place
+      operation: t.UpdateExpression['operator']
+      value: Place
+      loc: SourceLocation
+    }
+  | {
+      kind: 'PostfixUpdate'
+      lvalue: Place
+      operation: t.UpdateExpression['operator']
+      value: Place
+      loc: SourceLocation
+    }
+  | {
+      kind: 'Debugger'
+      loc: SourceLocation
+    }
+  | StartMemoize
+  | FinishMemoize
+  | {
+      kind: 'UnsupportedNode'
+      node: t.Node
+      loc: SourceLocation
+    }
+
+declare interface ITypeEnv {
+  popGeneric(name: string): void
+  getGeneric(name: string): null | TypeParameter<ResolvedType>
+  pushGeneric(
+    name: string,
+    binding: {
+      name: string
+      id: TypeParameterId
+      bound: ResolvedType
+    },
+  ): void
+  getType(id: Identifier): ResolvedType
+  getTypeOrNull(id: Identifier): ResolvedType | null
+  setType(id: Identifier, type: ResolvedType): void
+  nextNominalId(): NominalId
+  nextTypeParameterId(): TypeParameterId
+  moduleEnv: Map<string, ResolvedType>
+  addBinding(bindingIdentifier: t.Identifier, type: ResolvedType): void
+  resolveBinding(bindingIdentifier: t.Identifier): ResolvedType | null
+}
+
+declare type JsxAttribute =
+  | {
+      kind: 'JsxSpreadAttribute'
+      argument: Place
+    }
+  | {
+      kind: 'JsxAttribute'
+      name: string
+      place: Place
+    }
+
+declare type JsxExpression = {
+  kind: 'JsxExpression'
+  tag: Place | BuiltinTag
+  props: Array<JsxAttribute>
+  children: Array<Place> | null
+  loc: SourceLocation
+  openingLoc: SourceLocation
+  closingLoc: SourceLocation
+}
+
+declare type JSXText = {
+  kind: 'JSXText'
+  value: string
+  loc: SourceLocation
+}
+
+declare type LabelTerminal = {
+  kind: 'label'
+  block: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type LinearId = number & {
+  [opaqueLinearId]: 'LinearId'
+}
+
+declare type LoadContext = {
+  kind: 'LoadContext'
+  place: Place
+  loc: SourceLocation
+}
+
+export {loadEnv}
+
+declare type LoadGlobal = {
+  kind: 'LoadGlobal'
+  binding: NonLocalBinding
+  loc: SourceLocation
+}
+
+declare type LoadLocal = {
+  kind: 'LoadLocal'
+  place: Place
+  loc: SourceLocation
+}
+
+declare type Logger = {
+  logEvent: (filename: string | null, event: LoggerEvent) => void
+  debugLogIRs?: (value: CompilerPipelineValue) => void
+}
+
+declare type LoggerEvent =
+  | CompileSuccessEvent
+  | CompileErrorEvent
+  | CompileDiagnosticEvent
+  | CompileSkipEvent
+  | PipelineErrorEvent
+  | TimingEvent
+  | AutoDepsDecorationsEvent
+  | AutoDepsEligibleEvent
+
+declare type LogicalTerminal = {
+  kind: 'logical'
+  operator: t.LogicalExpression['operator']
+  test: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type LoweredFunction = {
+  func: HIRFunction
+}
+
+declare type LValue = {
+  place: Place
+  kind: InstructionKind
+}
+
+declare type LValuePattern = {
+  pattern: Pattern
+  kind: InstructionKind
+}
+
+declare type ManualMemoDependency = {
+  root:
+    | {
+        kind: 'NamedLocal'
+        value: Place
+      }
+    | {
+        kind: 'Global'
+        identifierName: string
+      }
+  path: DependencyPath
+}
+
+declare type MaybeThrowTerminal = {
+  kind: 'maybe-throw'
+  continuation: BlockId
+  handler: BlockId
+  id: InstructionId
+  loc: SourceLocation
+  fallthrough?: never
+  effects: Array<AliasingEffect> | null
+}
+
+declare type MethodCall = {
+  kind: 'MethodCall'
+  receiver: Place
+  property: Place
+  args: Array<Place | SpreadPattern>
+  loc: SourceLocation
+}
+
+declare type MutableRange = {
+  start: InstructionId
+  end: InstructionId
+}
+
+declare type MutationReason = {
+  kind: 'AssignCurrentProperty'
+}
+
+declare type NewExpression = {
+  kind: 'NewExpression'
+  callee: Place
+  args: Array<Place | SpreadPattern>
+  loc: SourceLocation
+}
+
+declare type NominalId = number & {
+  [opaqueNominalId]: 'NominalId'
+}
+
+declare type NonLocalBinding =
+  | {
+      kind: 'ImportDefault'
+      name: string
+      module: string
+    }
+  | {
+      kind: 'ImportNamespace'
+      name: string
+      module: string
+    }
+  | NonLocalImportSpecifier
+  | {
+      kind: 'ModuleLocal'
+      name: string
+    }
+  | {
+      kind: 'Global'
+      name: string
+    }
+
+declare type NonLocalImportSpecifier = {
+  kind: 'ImportSpecifier'
+  name: string
+  module: string
+  imported: string
+}
+
+declare type ObjectMethod$1 = {
+  kind: 'ObjectMethod'
+}
+
+declare type ObjectMethod = {
+  kind: 'ObjectMethod'
+  loc: SourceLocation
+  loweredFunc: LoweredFunction
+}
+
+declare type ObjectPattern = {
+  kind: 'ObjectPattern'
+  properties: Array<ObjectProperty | SpreadPattern>
+}
+
+declare type ObjectProperty = {
+  kind: 'ObjectProperty'
+  key: ObjectPropertyKey
+  type: 'property' | 'method'
+  place: Place
+}
+
+declare type ObjectPropertyKey =
+  | {
+      kind: 'string'
+      name: string
+    }
+  | {
+      kind: 'identifier'
+      name: string
+    }
+  | {
+      kind: 'computed'
+      name: Place
+    }
+  | {
+      kind: 'number'
+      name: number
+    }
+
+declare type ObjectType = {
+  kind: 'Object'
+  shapeId: string | null
+}
+
+declare class OkImpl<T> implements Result<T, never> {
+  #private
+  constructor(val: T)
+  map<U>(fn: (val: T) => U): Result<U, never>
+  mapErr<F>(_fn: (val: never) => F): Result<T, F>
+  mapOr<U>(_fallback: U, fn: (val: T) => U): U
+  mapOrElse<U>(_fallback: () => U, fn: (val: T) => U): U
+  andThen<U>(fn: (val: T) => Result<U, never>): Result<U, never>
+  and<U>(res: Result<U, never>): Result<U, never>
+  or(_res: Result<T, never>): Result<T, never>
+  orElse<F>(_fn: (val: never) => Result<T, F>): Result<T, F>
+  isOk(): this is OkImpl<T>
+  isErr(): this is ErrImpl<never>
+  expect(_msg: string): T
+  expectErr(msg: string): never
+  unwrap(): T
+  unwrapOr(_fallback: T): T
+  unwrapOrElse(_fallback: (val: never) => T): T
+  unwrapErr(): never
+}
+
+declare const opageDeclarationId: unique symbol
+
+declare const opaqueBlockId: unique symbol
+
+declare const opaqueIdentifierId: unique symbol
+
+declare const opaqueInstructionId: unique symbol
+
+declare const opaqueLinearId: unique symbol
+
+declare const opaqueNominalId: unique symbol
+
+declare const opaquePropertyLiteral: unique symbol
+
+declare const opaqueScopeId: unique symbol
+
+declare const opaqueTypeId: unique symbol
+
+declare const opaqueTypeParameterId: unique symbol
+
+declare const opaqueValidIdentifierName: unique symbol
+
+declare type OptionalTerminal = {
+  kind: 'optional'
+  optional: boolean
+  test: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+  loc: SourceLocation
+}
+
+/**
+ * @public
+ */
+export declare interface PackageJson {
+  name: string
+  version: string
+  author?: string
+  dependencies?: Record<string, string>
+  description?: string
+  devDependencies?: Record<string, string>
+  engines?: Record<string, string>
+  license?: string
+  peerDependencies?: Record<string, string>
+  private?: boolean
+  repository?: {
+    type: string
+    url: string
+  }
+  scripts?: Record<string, string>
+}
+
+declare type PanicThresholdOptions = z.infer<typeof PanicThresholdOptionsSchema>
+
+declare const PanicThresholdOptionsSchema: z.ZodEnum<{
+  none: 'none'
+  all_errors: 'all_errors'
+  critical_errors: 'critical_errors'
+}>
+
+declare type ParsedPluginOptions = Required<Omit<PluginOptions, 'environment'>> & {
+  environment: EnvironmentConfig
+}
+
+declare type Pattern = ArrayPattern | ObjectPattern
+
+declare type Phi = {
+  kind: 'Phi'
+  place: Place
+  operands: Map<BlockId, Place>
+}
+
+declare type PhiType = {
+  kind: 'Phi'
+  operands: Array<Type>
+}
+
+declare type PipelineErrorEvent = {
+  kind: 'PipelineError'
+  fnLoc: t.SourceLocation | null
+  data: string
+}
+
+declare type Place = {
+  kind: 'Identifier'
+  identifier: Identifier
+  effect: Effect
+  reactive: boolean
+  loc: SourceLocation
+}
+
+declare type Platform = 'client' | 'server' | 'shared'
+
+declare type PluginOptions = Partial<{
+  environment: Partial<EnvironmentConfig>
+  logger: Logger | null
+  gating: ExternalFunction | null
+  dynamicGating: DynamicGatingOptions | null
+  panicThreshold: PanicThresholdOptions
+  noEmit: boolean
+  compilationMode: CompilationMode
+  eslintSuppressionRules: Array<string> | null | undefined
+  flowSuppressions: boolean
+  ignoreUseNoForget: boolean
+  customOptOutDirectives: CustomOptOutDirective
+  sources: Array<string> | ((filename: string) => boolean) | null
+  enableReanimatedCheck: boolean
+  target: CompilerReactTarget
+}>
+
+declare type PolyType = {
+  kind: 'Poly'
+}
+
+declare type PrimitiveType = {
+  kind: 'Primitive'
+}
+
+declare type PrintErrorMessageOptions = {
+  eslint: boolean
+}
+
+declare class ProgramContext {
+  scope: Scope
+  opts: ParsedPluginOptions
+  filename: string | null
+  code: string | null
+  reactRuntimeModule: string
+  suppressions: Array<SuppressionRange>
+  hasModuleScopeOptOut: boolean
+  alreadyCompiled: WeakSet<object> | Set<object>
+  knownReferencedNames: Set<string>
+  imports: Map<string, Map<string, NonLocalImportSpecifier>>
+  retryErrors: Array<{
+    fn: BabelFn
+    error: CompilerError
+  }>
+  inferredEffectLocations: Set<t.SourceLocation>
+  constructor({
+    program,
+    suppressions,
+    opts,
+    filename,
+    code,
+    hasModuleScopeOptOut,
+  }: ProgramContextOptions)
+  isHookName(name: string): boolean
+  hasReference(name: string): boolean
+  newUid(name: string): string
+  addMemoCacheImport(): NonLocalImportSpecifier
+  addImportSpecifier(
+    {source: module, importSpecifierName: specifier}: ExternalFunction,
+    nameHint?: string,
+  ): NonLocalImportSpecifier
+  addNewReference(name: string): void
+  assertGlobalBinding(name: string, localScope?: Scope): Result<void, CompilerError>
+  logEvent(event: LoggerEvent): void
+}
+
+declare type ProgramContextOptions = {
+  program: NodePath<t.Program>
+  suppressions: Array<SuppressionRange>
+  opts: ParsedPluginOptions
+  filename: string | null
+  code: string | null
+  hasModuleScopeOptOut: boolean
+}
+
+declare type PromotedIdentifier = {
+  kind: 'promoted'
+  value: string
+}
+
+declare type PropertyLiteral = (string | number) & {
+  [opaquePropertyLiteral]: 'PropertyLiteral'
+}
+
+declare type PropertyLoad = {
+  kind: 'PropertyLoad'
+  object: Place
+  property: PropertyLiteral
+  loc: SourceLocation
+}
+
+declare type PropType = {
+  kind: 'Property'
+  objectType: Type
+  objectName: string
+  propertyName:
+    | {
+        kind: 'literal'
+        value: PropertyLiteral
+      }
+    | {
+        kind: 'computed'
+        value: Type
+      }
+}
+
+declare type PrunedReactiveScopeBlock = {
+  kind: 'pruned-scope'
+  scope: ReactiveScope
+  instructions: ReactiveBlock
+}
+
+declare type PrunedScopeTerminal = {
+  kind: 'pruned-scope'
+  fallthrough: BlockId
+  block: BlockId
+  scope: ReactiveScope
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactFunctionType = 'Component' | 'Hook' | 'Other'
+
+declare type ReactiveBlock = Array<ReactiveStatement>
+
+declare type ReactiveBreakTerminal = {
+  kind: 'break'
+  target: BlockId
+  id: InstructionId
+  targetKind: ReactiveTerminalTargetKind
+  loc: SourceLocation
+}
+
+declare type ReactiveContinueTerminal = {
+  kind: 'continue'
+  target: BlockId
+  id: InstructionId
+  targetKind: ReactiveTerminalTargetKind
+  loc: SourceLocation
+}
+
+declare type ReactiveDoWhileTerminal = {
+  kind: 'do-while'
+  loop: ReactiveBlock
+  test: ReactiveValue
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactiveForInTerminal = {
+  kind: 'for-in'
+  init: ReactiveValue
+  loop: ReactiveBlock
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactiveForOfTerminal = {
+  kind: 'for-of'
+  init: ReactiveValue
+  test: ReactiveValue
+  loop: ReactiveBlock
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactiveForTerminal = {
+  kind: 'for'
+  init: ReactiveValue
+  test: ReactiveValue
+  update: ReactiveValue | null
+  loop: ReactiveBlock
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactiveFunction = {
+  loc: SourceLocation
+  id: ValidIdentifierName | null
+  nameHint: string | null
+  params: Array<Place | SpreadPattern>
+  generator: boolean
+  async: boolean
+  body: ReactiveBlock
+  env: Environment
+  directives: Array<string>
+}
+
+declare type ReactiveIfTerminal = {
+  kind: 'if'
+  test: Place
+  consequent: ReactiveBlock
+  alternate: ReactiveBlock | null
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactiveInstruction = {
+  id: InstructionId
+  lvalue: Place | null
+  value: ReactiveValue
+  effects?: Array<AliasingEffect> | null
+  loc: SourceLocation
+}
+
+declare type ReactiveInstructionStatement = {
+  kind: 'instruction'
+  instruction: ReactiveInstruction
+}
+
+declare type ReactiveLabelTerminal = {
+  kind: 'label'
+  block: ReactiveBlock
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactiveLogicalValue = {
+  kind: 'LogicalExpression'
+  operator: t.LogicalExpression['operator']
+  left: ReactiveValue
+  right: ReactiveValue
+  loc: SourceLocation
+}
+
+declare type ReactiveOptionalCallValue = {
+  kind: 'OptionalExpression'
+  id: InstructionId
+  value: ReactiveValue
+  optional: boolean
+  loc: SourceLocation
+}
+
+declare type ReactiveReturnTerminal = {
+  kind: 'return'
+  value: Place
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactiveScope = {
+  id: ScopeId
+  range: MutableRange
+  dependencies: ReactiveScopeDependencies
+  declarations: Map<IdentifierId, ReactiveScopeDeclaration>
+  reassignments: Set<Identifier>
+  earlyReturnValue: {
+    value: Identifier
+    loc: SourceLocation
+    label: BlockId
+  } | null
+  merged: Set<ScopeId>
+  loc: SourceLocation
+}
+
+declare type ReactiveScopeBlock = {
+  kind: 'scope'
+  scope: ReactiveScope
+  instructions: ReactiveBlock
+}
+
+declare type ReactiveScopeDeclaration = {
+  identifier: Identifier
+  scope: ReactiveScope
+}
+
+declare type ReactiveScopeDependencies = Set<ReactiveScopeDependency>
+
+declare type ReactiveScopeDependency = {
+  identifier: Identifier
+  reactive: boolean
+  path: DependencyPath
+}
+
+declare type ReactiveScopeTerminal = {
+  kind: 'scope'
+  fallthrough: BlockId
+  block: BlockId
+  scope: ReactiveScope
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactiveSequenceValue = {
+  kind: 'SequenceExpression'
+  instructions: Array<ReactiveInstruction>
+  id: InstructionId
+  value: ReactiveValue
+  loc: SourceLocation
+}
+
+declare type ReactiveStatement =
+  | ReactiveInstructionStatement
+  | ReactiveTerminalStatement
+  | ReactiveScopeBlock
+  | PrunedReactiveScopeBlock
+
+declare type ReactiveSwitchTerminal = {
+  kind: 'switch'
+  test: Place
+  cases: Array<{
+    test: Place | null
+    block: ReactiveBlock | void
+  }>
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactiveTerminal =
+  | ReactiveBreakTerminal
+  | ReactiveContinueTerminal
+  | ReactiveReturnTerminal
+  | ReactiveThrowTerminal
+  | ReactiveSwitchTerminal
+  | ReactiveDoWhileTerminal
+  | ReactiveWhileTerminal
+  | ReactiveForTerminal
+  | ReactiveForOfTerminal
+  | ReactiveForInTerminal
+  | ReactiveIfTerminal
+  | ReactiveLabelTerminal
+  | ReactiveTryTerminal
+
+declare type ReactiveTerminalStatement<Tterminal extends ReactiveTerminal = ReactiveTerminal> = {
+  kind: 'terminal'
+  terminal: Tterminal
+  label: {
+    id: BlockId
+    implicit: boolean
+  } | null
+}
+
+declare type ReactiveTerminalTargetKind = 'implicit' | 'labeled' | 'unlabeled'
+
+declare type ReactiveTernaryValue = {
+  kind: 'ConditionalExpression'
+  test: ReactiveValue
+  consequent: ReactiveValue
+  alternate: ReactiveValue
+  loc: SourceLocation
+}
+
+declare type ReactiveThrowTerminal = {
+  kind: 'throw'
+  value: Place
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactiveTryTerminal = {
+  kind: 'try'
+  block: ReactiveBlock
+  handlerBinding: Place | null
+  handler: ReactiveBlock
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ReactiveValue =
+  | InstructionValue
+  | ReactiveLogicalValue
+  | ReactiveSequenceValue
+  | ReactiveTernaryValue
+  | ReactiveOptionalCallValue
+
+declare type ReactiveWhileTerminal = {
+  kind: 'while'
+  test: ReactiveValue
+  loop: ReactiveBlock
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ResolvedType = {
+  kind: 'Concrete'
+  type: ConcreteType<ResolvedType>
+  platform: Platform
+}
+
+declare interface Result<T, E> {
+  map<U>(fn: (val: T) => U): Result<U, E>
+  mapErr<F>(fn: (val: E) => F): Result<T, F>
+  mapOr<U>(fallback: U, fn: (val: T) => U): U
+  mapOrElse<U>(fallback: () => U, fn: (val: T) => U): U
+  andThen<U>(fn: (val: T) => Result<U, E>): Result<U, E>
+  and<U>(res: Result<U, E>): Result<U, E>
+  or(res: Result<T, E>): Result<T, E>
+  orElse<F>(fn: (val: E) => Result<T, F>): Result<T, F>
+  isOk(): this is OkImpl<T>
+  isErr(): this is ErrImpl<E>
+  expect(msg: string): T
+  expectErr(msg: string): E
+  unwrap(): T
+  unwrapOr(fallback: T): T
+  unwrapOrElse(fallback: (val: E) => T): T
+  unwrapErr(): E
+}
+
+declare type ReturnTerminal = {
+  kind: 'return'
+  returnVariant: ReturnVariant
+  loc: SourceLocation
+  value: Place
+  id: InstructionId
+  fallthrough?: never
+  effects: Array<AliasingEffect> | null
+}
+
+declare type ReturnVariant = 'Void' | 'Implicit' | 'Explicit'
+
+declare type ScopeId = number & {
+  [opaqueScopeId]: 'ScopeId'
+}
+
+declare type SequenceTerminal = {
+  kind: 'sequence'
+  block: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type SourceLocation = t.SourceLocation | typeof GeneratedSource
+
+declare type SpreadPattern = {
+  kind: 'Spread'
+  place: Place
+}
+
+declare type StartMemoize = {
+  kind: 'StartMemoize'
+  manualMemoId: number
+  deps: Array<ManualMemoDependency> | null
+  loc: SourceLocation
+}
+
+declare type StoreGlobal = {
+  kind: 'StoreGlobal'
+  name: string
+  value: Place
+  loc: SourceLocation
+}
+
+declare type StoreLocal = {
+  kind: 'StoreLocal'
+  lvalue: LValue
+  value: Place
+  type: t.FlowType | t.TSType | null
+  loc: SourceLocation
+}
+
+declare type SuppressionRange = {
+  disableComment: t.Comment
+  enableComment: t.Comment | null
+  source: SuppressionSource
+}
+
+declare type SuppressionSource = 'Eslint' | 'Flow'
+
+declare type SwitchTerminal = {
+  kind: 'switch'
+  test: Place
+  cases: Array<Case>
+  fallthrough: BlockId
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type Terminal =
+  | UnsupportedTerminal
+  | UnreachableTerminal
+  | ThrowTerminal
+  | ReturnTerminal
+  | GotoTerminal
+  | IfTerminal
+  | BranchTerminal
+  | SwitchTerminal
+  | ForTerminal
+  | ForOfTerminal
+  | ForInTerminal
+  | DoWhileTerminal
+  | WhileTerminal
+  | LogicalTerminal
+  | TernaryTerminal
+  | OptionalTerminal
+  | LabelTerminal
+  | SequenceTerminal
+  | MaybeThrowTerminal
+  | TryTerminal
+  | ReactiveScopeTerminal
+  | PrunedScopeTerminal
+
+declare type TernaryTerminal = {
+  kind: 'ternary'
+  test: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type ThrowTerminal = {
+  kind: 'throw'
+  value: Place
+  id: InstructionId
+  loc: SourceLocation
+  fallthrough?: never
+}
+
+declare type TimingEvent = {
+  kind: 'Timing'
+  measurement: PerformanceMeasure
+}
+
+declare type TryTerminal = {
+  kind: 'try'
+  block: BlockId
+  handlerBinding: Place | null
+  handler: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+  loc: SourceLocation
+}
+
+declare type Type = BuiltInType | PhiType | TypeVar | PolyType | PropType | ObjectMethod$1
+
+declare type TypeId = number & {
+  [opaqueTypeId]: 'IdentifierId'
+}
+
+declare type TypeParameter<T> = {
+  name: string
+  id: TypeParameterId
+  bound: T
+}
+
+declare type TypeParameterId = number & {
+  [opaqueTypeParameterId]: 'TypeParameterId'
+}
+
+declare type TypeVar = {
+  kind: 'Type'
+  id: TypeId
+}
+
+declare type UnreachableTerminal = {
+  kind: 'unreachable'
+  id: InstructionId
+  loc: SourceLocation
+  fallthrough?: never
+}
+
+declare type UnsupportedTerminal = {
+  kind: 'unsupported'
+  id: InstructionId
+  loc: SourceLocation
+  fallthrough?: never
+}
+
+declare type ValidatedIdentifier = {
+  kind: 'named'
+  value: ValidIdentifierName
+}
+
+declare type ValidIdentifierName = string & {
+  [opaqueValidIdentifierName]: 'ValidIdentifierName'
+}
+
+declare enum ValueKind {
+  MaybeFrozen = 'maybefrozen',
+  Frozen = 'frozen',
+  Primitive = 'primitive',
+  Global = 'global',
+  Mutable = 'mutable',
+  Context = 'context',
+}
+
+declare enum ValueReason {
+  Global = 'global',
+  JsxCaptured = 'jsx-captured',
+  HookCaptured = 'hook-captured',
+  HookReturn = 'hook-return',
+  Effect = 'effect',
+  KnownReturnSignature = 'known-return-signature',
+  Context = 'context',
+  State = 'state',
+  ReducerState = 'reducer-state',
+  ReactiveFunctionArgument = 'reactive-function-argument',
+  Other = 'other',
+}
+
+declare type WhileTerminal = {
+  kind: 'while'
+  loc: SourceLocation
+  test: BlockId
+  loop: BlockId
+  fallthrough: BlockId
+  id: InstructionId
+}
+
+export {}