@sanity/cli 6.0.0-alpha.9 → 6.0.0

package/dist/index.d.ts

@@ -1,2326 +0,0 @@
-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 {}