@sanity/codegen 5.7.0-next.8 → 5.7.0

package/lib/index.d.ts

@@ -1,433 +0,0 @@
-import {ExprNode} from 'groq-js'
-import {SchemaType} from 'groq-js'
-import * as t from '@babel/types'
-import {TransformOptions} from '@babel/core'
-import {WorkerChannel} from '@sanity/worker-channels'
-import {WorkerChannelReporter} from '@sanity/worker-channels'
-import * as z from 'zod'
-
-/**
- * @deprecated use TypeGenConfig
- */
-export declare type CodegenConfig = TypeGenConfig
-
-/**
- * @internal
- */
-export declare const configDefinition: z.ZodObject<
-  {
-    path: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, 'many'>]>>
-    schema: z.ZodDefault<z.ZodString>
-    generates: z.ZodDefault<z.ZodString>
-    formatGeneratedCode: z.ZodDefault<z.ZodBoolean>
-    overloadClientMethods: z.ZodDefault<z.ZodBoolean>
-  },
-  'strip',
-  z.ZodTypeAny,
-  {
-    path: string | string[]
-    schema: string
-    generates: string
-    formatGeneratedCode: boolean
-    overloadClientMethods: boolean
-  },
-  {
-    path?: string | string[] | undefined
-    schema?: string | undefined
-    generates?: string | undefined
-    formatGeneratedCode?: boolean | undefined
-    overloadClientMethods?: boolean | undefined
-  }
->
-
-/**
- * A module containing queries that have been evaluated.
- * @public
- */
-export declare interface EvaluatedModule {
-  filename: string
-  queries: EvaluatedQuery[]
-  errors: (QueryExtractionError | QueryEvaluationError)[]
-}
-
-/**
- * An `ExtractedQuery` that has been evaluated against a schema, yielding a TypeScript type.
- * @public
- */
-export declare interface EvaluatedQuery extends ExtractedQuery {
-  id: t.Identifier
-  code: string
-  tsType: t.TSType
-  ast: t.ExportNamedDeclaration
-  stats: TypeEvaluationStats
-}
-
-/**
- * A module (file) containing extracted GROQ queries.
- * @public
- */
-export declare interface ExtractedModule {
-  filename: string
-  queries: ExtractedQuery[]
-  errors: QueryExtractionError[]
-}
-
-/**
- * A GROQ query extracted from a source file.
- * @public
- */
-export declare interface ExtractedQuery {
-  variable: QueryVariable
-  query: string
-  filename: string
-}
-
-/**
- * Filter a union of object types by the _type property. This is handy when working with page builder
- * setups where the returned type is an array containing multiple types.
- *
- * @example
- * ```ts
- *
- * export type Callout = {
- *   _type: 'callout'
- *   title?: string
- *   content?: string
- * }
- *
- * export type Video = {
- *   _type: 'video'
- *   url?: string
- *   caption?: string
- * }
- * type FORM_QUERY_RESULT = {
- *   _id: string
- *   title?: string
- *   content?: Array<
- *     | ({ _key: string } & Callout)
- *     | ({ _key: string } & Video)
- *   >
- * } | null
- *
- * // Get the type of the content with the Get helper
- * type Content = Get<FORM_QUERY_RESULT, 'content', number>
- *
- * // Get the type for a callout module from the page builder type
- * type CalloutModule = FilterByType<Content, 'callout'>
- * // → { _key: string } & Callout
- * ```
- */
-export declare type FilterByType<
-  U extends {
-    _type: string
-  },
-  T extends U['_type'],
-> = Extract<
-  U,
-  {
-    _type: T
-  }
->
-
-/**
- * findQueriesInPath takes a path or array of paths and returns all GROQ queries in the files.
- * @param path - The path or array of paths to search for queries
- * @param babelOptions - The babel configuration to use when parsing the source
- * @param resolver - A resolver function to use when resolving module imports
- * @returns An async generator that yields the results of the search
- * @beta
- * @internal
- */
-export declare function findQueriesInPath({
-  path,
-  babelOptions,
-  resolver,
-}: FindQueriesInPathOptions): {
-  files: string[]
-  queries: AsyncIterable<ExtractedModule>
-}
-
-declare interface FindQueriesInPathOptions {
-  path: string | string[]
-  babelOptions?: TransformOptions
-  resolver?: NodeJS.RequireResolve
-}
-
-/**
- * findQueriesInSource takes a source string and returns all GROQ queries in it.
- * @param source - The source code to search for queries
- * @param filename - The filename of the source code
- * @param babelConfig - The babel configuration to use when parsing the source
- * @param resolver - A resolver function to use when resolving module imports
- * @returns
- * @beta
- * @internal
- */
-export declare function findQueriesInSource(
-  source: string,
-  filename: string,
-  babelConfig?: TransformOptions,
-  resolver?: NodeJS.RequireResolve,
-): ExtractedModule
-
-export declare interface GenerateTypesOptions {
-  schema: SchemaType
-  schemaPath?: string
-  queries?: AsyncIterable<ExtractedModule>
-  root?: string
-  overloadClientMethods?: boolean
-  reporter?: WorkerChannelReporter<TypegenWorkerChannel>
-}
-
-/**
- * Get a deeply nested property type from a complex type structure. Safely navigates
- * through nullable types (`T | null | undefined`) at each level, preserving the
- * nullability of the final accessed property.
- *
- * Supports up to 20 levels of nesting.
- *
- * @example
- * ```ts
- * type POST_QUERY_RESULT = {
- *   _id: string
- *   author: {
- *     profile: {
- *       name: string;
- *     } | null;
- *   } | null;
- *   links: Array<{
- *     _key: string
- *     type: 'link'
- *     label: string
- *     url: string
- *   }> | null
- * } | null
- *
- * // Basic property access:
- * type Id = Get<POST_QUERY_RESULT, '_id'>;
- * // → string
- *
- * // Nested property access:
- * type Profile = Get<POST_QUERY_RESULT, 'author', 'profile';
- * // → { name: string } | null
- *
- * // Array element access using `number`:
- * type Link = Get<POST_QUERY_RESULT, 'links', number, 'label'>;
- * // → string
- * ```
- */
-export declare type Get<
-  T,
-  K1 extends keyof NonNullish<T>,
-  K2 extends keyof NavigatePath<T, [K1]> = never,
-  K3 extends keyof NavigatePath<T, [K1, K2]> = never,
-  K4 extends keyof NavigatePath<T, [K1, K2, K3]> = never,
-  K5 extends keyof NavigatePath<T, [K1, K2, K3, K4]> = never,
-  K6 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5]> = never,
-  K7 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6]> = never,
-  K8 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7]> = never,
-  K9 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8]> = never,
-  K10 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9]> = never,
-  K11 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10]> = never,
-  K12 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11]> = never,
-  K13 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12]> = never,
-  K14 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13]> =
-    never,
-  K15 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14]> =
-    never,
-  K16 extends keyof NavigatePath<
-    T,
-    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15]
-  > = never,
-  K17 extends keyof NavigatePath<
-    T,
-    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16]
-  > = never,
-  K18 extends keyof NavigatePath<
-    T,
-    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17]
-  > = never,
-  K19 extends keyof NavigatePath<
-    T,
-    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18]
-  > = never,
-  K20 extends keyof NavigatePath<
-    T,
-    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19]
-  > = never,
-> = GetAtPath<
-  T,
-  TakeUntilNever<
-    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K20]
-  >
->
-
-/** Recursively gets value at path, preserving nullability at final access. */
-declare type GetAtPath<T, Path extends unknown[]> = Path extends []
-  ? T
-  : Path extends [infer K]
-    ? K extends keyof NonNullish<T>
-      ? NonNullish<T>[K]
-      : never
-    : Path extends [infer K, ...infer Rest]
-      ? K extends keyof NonNullish<T>
-        ? GetAtPath<NonNullish<T>[K], Rest>
-        : never
-      : never
-
-/**
- * This is a custom implementation of require.resolve that takes into account the paths
- * configuration in tsconfig.json. This is necessary if we want to resolve paths that are
- * custom defined in the tsconfig.json file.
- * Resolving here is best effort and might not work in all cases.
- * @beta
- */
-export declare function getResolver(cwd?: string): NodeJS.RequireResolve
-
-/** Recursively navigates through a path, stripping nullability for key lookup. */
-declare type NavigatePath<T, Path extends unknown[]> = Path extends []
-  ? NonNullish<T>
-  : Path extends [infer K, ...infer Rest]
-    ? K extends keyof NonNullish<T>
-      ? NavigatePath<NonNullish<T>[K], Rest>
-      : never
-    : never
-
-/** Excludes `null` and `undefined` from a type. */
-declare type NonNullish<T> = T extends null | undefined ? never : T
-
-/**
- * An error that occurred during query evaluation.
- * @public
- */
-declare class QueryEvaluationError extends Error {
-  variable?: QueryVariable
-  filename: string
-  constructor({variable, cause, filename}: QueryEvaluationErrorOptions)
-}
-
-declare interface QueryEvaluationErrorOptions {
-  variable?: QueryVariable
-  cause: unknown
-  filename: string
-}
-
-/**
- * An error that occurred during query extraction.
- * @public
- */
-export declare class QueryExtractionError extends Error {
-  variable?: QueryVariable
-  filename: string
-  constructor({variable, cause, filename}: QueryExtractionErrorOptions)
-}
-
-declare interface QueryExtractionErrorOptions {
-  variable?: QueryVariable
-  cause: unknown
-  filename: string
-}
-
-declare interface QueryVariable {
-  id: t.Identifier
-  start?: number
-  end?: number
-}
-
-/**
- * Read, parse and process a config file
- * @internal
- */
-export declare function readConfig(path: string): Promise<TypeGenConfig>
-
-/**
- * Read a schema from a given path
- * @param path - The path to the schema
- * @returns The schema
- * @internal
- * @beta
- **/
-export declare function readSchema(path: string): Promise<SchemaType>
-
-/**
- * Register Babel with the given options
- *
- * @param babelOptions - The options to use when registering Babel
- * @beta
- */
-export declare function registerBabel(babelOptions?: TransformOptions): void
-
-/**
- * safeParseQuery parses a GROQ query string, but first attempts to extract any parameters used in slices. This method is _only_
- * intended for use in type generation where we don't actually execute the parsed AST on a dataset, and should not be used elsewhere.
- * @internal
- */
-export declare function safeParseQuery(query: string): ExprNode
-
-/** Builds a tuple from elements, stopping at the first `never`. */
-declare type TakeUntilNever<T extends unknown[]> = T extends [infer H, ...infer Rest]
-  ? [H] extends [never]
-    ? []
-    : [H, ...TakeUntilNever<Rest>]
-  : []
-
-/**
- * Statistics from the query type evaluation process.
- * @public
- */
-declare interface TypeEvaluationStats {
-  allTypes: number
-  unknownTypes: number
-  emptyUnions: number
-}
-
-export declare type TypeGenConfig = z.infer<typeof configDefinition>
-
-/**
- * A class used to generate TypeScript types from a given schema
- * @beta
- */
-export declare class TypeGenerator {
-  private getInternalReferenceSymbolDeclaration
-  private getArrayOfDeclaration
-  private getSchemaTypeGenerator
-  private getSchemaTypeDeclarations
-  private getAllSanitySchemaTypesDeclaration
-  private static getEvaluatedModules
-  private static getQueryMapDeclaration
-  generateTypes(options: GenerateTypesOptions): Promise<{
-    code: string
-    ast: t.Program
-  }>
-}
-
-export declare type TypegenWorkerChannel = WorkerChannel.Definition<{
-  generatedSchemaTypes: WorkerChannel.Event<{
-    internalReferenceSymbol: {
-      id: t.Identifier
-      code: string
-      ast: t.ExportNamedDeclaration
-    }
-    schemaTypeDeclarations: {
-      id: t.Identifier
-      name: string
-      code: string
-      tsType: t.TSType
-      ast: t.ExportNamedDeclaration
-    }[]
-    allSanitySchemaTypesDeclaration: {
-      code: string
-      id: t.Identifier
-      ast: t.ExportNamedDeclaration
-    }
-  }>
-  evaluatedModules: WorkerChannel.Stream<EvaluatedModule>
-  generatedQueryTypes: WorkerChannel.Event<{
-    queryMapDeclaration: {
-      code: string
-      ast: t.Program
-    }
-  }>
-}>
-
-export {}