@sanity-typed/types/dist/internal.d.mts

Infer Sanity Document Types from Sanity Schemas

import { RuleDef, PreviewConfig, ArrayDefinition as ArrayDefinition$1, ArrayRule, BlockDecoratorDefinition as BlockDecoratorDefinition$1, BlockDefinition as BlockDefinition$1, CustomValidator, BlockRule, BlockListDefinition as BlockListDefinition$1, BlockMarksDefinition, BlockStyleDefinition as BlockStyleDefinition$1, BooleanDefinition as BooleanDefinition$1, BooleanRule, CrossDatasetReferenceDefinition as CrossDatasetReferenceDefinition$1, DateDefinition as DateDefinition$1, DateRule, DatetimeDefinition as DatetimeDefinition$1, DatetimeRule, DocumentDefinition as DocumentDefinition$1, EmailDefinition as EmailDefinition$1, EmailRule, FileDefinition as FileDefinition$1, ReferenceValue as ReferenceValue$1, FileRule, GeopointDefinition as GeopointDefinition$1, GeopointValue, GeopointRule, ImageDefinition as ImageDefinition$1, ImageCrop, ImageHotspot, ImageRule, ImageOptions, NumberDefinition as NumberDefinition$1, NumberRule, NumberOptions, ObjectDefinition as ObjectDefinition$1, ObjectRule, ReferenceDefinition as ReferenceDefinition$1, ReferenceRule, TypeReference as TypeReference$1, SlugDefinition as SlugDefinition$1, SlugValue as SlugValue$1, SlugRule, StringDefinition as StringDefinition$1, StringRule, StringOptions, TextDefinition as TextDefinition$1, TextRule, UrlDefinition as UrlDefinition$1, UrlRule, StrictDefinition, MaybeAllowUnknownProps, TypeAliasDefinition as TypeAliasDefinition$1, PluginOptions as PluginOptions$1, SchemaPluginOptions, ComposableOption, ConfigContext, BetaFeatures, WorkspaceOptions as WorkspaceOptions$1, ScheduledPublishingPluginOptions, FileAsset as FileAsset$1, ImageAsset as ImageAsset$1, defineType as defineType$1, defineArrayMember as defineArrayMember$1, FieldDefinitionBase, defineField as defineField$1, Plugin, DefineSchemaOptions } from 'sanity';
import { IsNumericLiteral, Simplify, Except, IsStringLiteral, Merge, OmitIndexSignature } from 'type-fest';
import { PortableTextBlock, PortableTextSpan } from '@portabletext-typed/types';
import { BlockStyleDefault, BlockListItemDefault, BlockMarkDecoratorDefault } from '@portabletext-typed/types/src/internal';

type IsPlainObject<T> = T extends any[] ? false : T extends object ? true : false;
type MaybeArray<T> = T | T[];
type ReadonlyTupleOfLength<T, Min extends number = number, Max extends number = number, Result extends T[] = []> = Result["length"] extends Min ? IsNumericLiteral<Max> extends false ? readonly [...Result, ...T[]] : Result["length"] extends Max ? Result : ReadonlyTupleOfLength<T, [
    T,
    ...Result
]["length"] & number, Max, [
    T,
    ...Result
]> | Result : ReadonlyTupleOfLength<T, Min, Max, [T, ...Result]>;
type TupleOfLength<T, Min extends number = number, Max extends number = number, Result extends T[] = []> = Result["length"] extends Min ? IsNumericLiteral<Max> extends false ? [...Result, ...T[]] : Result["length"] extends Max ? Result : Result | TupleOfLength<T, [
    T,
    ...Result
]["length"] & number, Max, [
    T,
    ...Result
]> : TupleOfLength<T, Min, Max, [T, ...Result]>;

type Merge_<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;
type MergeOld<FirstType, SecondType> = Simplify<Merge_<FirstType, SecondType>>;
declare const README: unique symbol;
declare const required: unique symbol;
type WithRequired<TRequired extends boolean, Rule extends RuleDef<Rule, any>> = MergeOld<{
    [key in keyof Rule]: Rule[key] extends (...args: infer Args) => Rule ? (...args: Args) => WithRequired<TRequired, Rule> : Rule[key];
}, {
    optional: () => WithRequired<false, Rule>;
    required: (...args: Parameters<Rule["required"]>) => WithRequired<true, Rule>;
    [required]: TRequired;
    warning: (...args: Parameters<Rule["warning"]>) => WithRequired<false, Rule>;
}>;
type ValidationBuilder<TRequired extends boolean, Value, Rule extends RuleDef<Rule, Value>> = (rule: WithRequired<false, Rule>) => MaybeArray<WithRequired<TRequired | false, Rule>>;
interface DefinitionBase<TRequired extends boolean, Value, Rule extends RuleDef<Rule, Value>> {
    preview?: PreviewConfig;
    validation?: ValidationBuilder<TRequired, Value, Rule>;
}
type GetOriginalRule<TDefinitionBase extends DefinitionBase<any, any, any>> = TDefinitionBase extends DefinitionBase<any, any, infer Rule> ? Rule : never;
type RewriteValue<Value, Rule extends RuleDef<Rule, any>> = MergeOld<{
    [key in keyof Rule]: Rule[key] extends (...args: infer Args) => Rule ? (...args: Args) => RewriteValue<Value, Rule> : Rule[key];
}, {
    custom: <LenientValue extends Value>(fn: CustomValidator<LenientValue | undefined>) => RewriteValue<Value, Rule>;
}>;
type BooleanDefinition<TRequired extends boolean> = MergeOld<BooleanDefinition$1, DefinitionBase<TRequired, boolean, BooleanRule>>;
interface CrossDatasetReferenceValue {
    _dataset: string;
    _projectId: string;
    _ref: string;
    _type: "crossDatasetReference";
    _weak?: boolean;
}
type CrossDatasetReferenceRule = RuleDef<CrossDatasetReferenceRule, CrossDatasetReferenceValue>;
type CrossDatasetReferenceDefinition<TRequired extends boolean> = MergeOld<CrossDatasetReferenceDefinition$1, DefinitionBase<TRequired, CrossDatasetReferenceValue, CrossDatasetReferenceRule>>;
type DateDefinition<TRequired extends boolean> = MergeOld<DateDefinition$1, DefinitionBase<TRequired, string, DateRule>>;
type DatetimeDefinition<TRequired extends boolean> = MergeOld<DatetimeDefinition$1, DefinitionBase<TRequired, string, DatetimeRule>>;
type EmailDefinition<TRequired extends boolean> = MergeOld<EmailDefinition$1, DefinitionBase<TRequired, string, EmailRule>>;
type GeopointDefinition<TRequired extends boolean> = MergeOld<GeopointDefinition$1, DefinitionBase<TRequired, GeopointValue, GeopointRule>>;
interface TitledListValue<T> {
    _key?: string;
    title: string;
    value: T;
}
type MaybeTitledListValue<T> = T | TitledListValue<T>;
type NumberDefinition<TNumberValue extends number, TRequired extends boolean> = MergeOld<NumberDefinition$1, DefinitionBase<TRequired, TNumberValue, RewriteValue<TNumberValue, NumberRule>> & {
    options?: MergeOld<NumberOptions, {
        list?: MaybeTitledListValue<TNumberValue>[];
    }>;
}>;
/**
 * **WARNING!!!**
 *
 * This is *not* used during runtime in any way.
 *
 * ReferenceValue will not actually have a key of this symbol.
 *
 * This is only used to help with type inference.
 *
 * DO NOT rely on or use this symbol in runtime in any way. Typescript won't complain but it won't be there. We *cannot* change the output of sanity's content lake to include anything, especially symbols.
 *
 * This is also true for the other `@sanity-typed/*` packages. Although they import this symbol, it's only for type inference.
 */
declare const referenced: unique symbol;
type ReferenceValue<TReferenced extends string, TReferenceWeak extends boolean = false> = MergeOld<Omit<ReferenceValue$1, "_key" | "_strengthenOnPublish" | "_weak">, (true extends TReferenceWeak ? Pick<ReferenceValue$1, "_strengthenOnPublish"> & {
    _weak?: true;
} : unknown) & {
    _type: "reference";
    [referenced]: TReferenced;
}>;
type TypeReference<TReferenced extends string> = MergeOld<TypeReference$1, {
    type: TReferenced & (IsStringLiteral<TReferenced> extends false ? {
        [README]: "⛔️ Unfortunately, this needs an `as const` for correct types. ⛔️";
    } : unknown);
}>;
type ReferenceDefinition<TReferenced extends string, TReferenceWeak extends boolean, TRequired extends boolean> = MergeOld<Omit<ReferenceDefinition$1, "weak">, DefinitionBase<TRequired, ReferenceValue<TReferenced, TReferenceWeak>, RewriteValue<ReferenceValue<TReferenced, TReferenceWeak>, ReferenceRule>> & {
    to: ReadonlyTupleOfLength<TypeReference<TReferenced>, 1> | TupleOfLength<TypeReference<TReferenced>, 1>;
    weak?: TReferenceWeak;
}>;
type SlugValue = Required<SlugValue$1>;
type SlugDefinition<TRequired extends boolean> = MergeOld<SlugDefinition$1, DefinitionBase<TRequired, SlugValue, RewriteValue<SlugValue, SlugRule>>>;
type RegexRule<Rule extends RuleDef<Rule, any>> = MergeOld<{
    [key in keyof Rule]: Rule[key] extends (...args: infer Args) => Rule ? (...args: Args) => RegexRule<Rule> : Rule[key];
}, {
    regex: (...args: [
        pattern: RegExp,
        name: string,
        options: {
            invert?: boolean;
        }
    ] | [pattern: RegExp, name: string] | [pattern: RegExp, options: {
        invert?: boolean;
        name?: string;
    }] | [pattern: RegExp]) => RegexRule<Rule>;
}>;
type StringDefinition<TStringValue extends string, TRequired extends boolean> = MergeOld<StringDefinition$1, DefinitionBase<TRequired, TStringValue, RewriteValue<TStringValue, RegexRule<StringRule>>> & {
    options?: MergeOld<StringOptions, {
        list?: MaybeTitledListValue<TStringValue>[];
    }>;
}>;
type TextDefinition<TRequired extends boolean> = MergeOld<TextDefinition$1, DefinitionBase<TRequired, string, RegexRule<TextRule>>>;
type UrlDefinition<TRequired extends boolean> = MergeOld<UrlDefinition$1, DefinitionBase<TRequired, string, UrlRule>>;
type InferRawValue<Def extends DefinitionBase<any, any, any>> = Def extends DefinitionBase<any, infer Value, any> ? Value : never;
type ArrayDefinition<TMemberDefinition extends DefinitionBase<any, any, any> & {
    name?: string;
}, TRequired extends boolean> = MergeOld<ArrayDefinition$1, DefinitionBase<TRequired, InferRawValue<TMemberDefinition>[], ArrayRule<InferRawValue<TMemberDefinition>[]>> & {
    of: TMemberDefinition[];
}>;
type BlockStyleDefinition<Value extends string> = MergeOld<BlockStyleDefinition$1, {
    value: Value;
}>;
type BlockListDefinition<Value extends string> = MergeOld<BlockListDefinition$1, {
    value: Value;
}>;
type BlockDecoratorDefinition<Value extends string> = MergeOld<BlockDecoratorDefinition$1, {
    value: Value;
}>;
type BlockDefinition<TBlockStyle extends string, TBlockListItem extends string, TBlockMarkDecorator extends string, TBlockMarkAnnotation extends DefinitionBase<any, any, any> & {
    name?: string;
}, TMemberDefinition extends DefinitionBase<any, any, any> & {
    name?: string;
}, TRequired extends boolean> = MergeOld<BlockDefinition$1, DefinitionBase<TRequired, PortableTextBlock<TBlockMarkDecorator, InferRawValue<TBlockMarkAnnotation>, InferRawValue<TMemberDefinition> | PortableTextSpan<TBlockMarkDecorator>, TBlockStyle, TBlockListItem>, RewriteValue<PortableTextBlock<TBlockMarkDecorator, InferRawValue<TBlockMarkAnnotation>, InferRawValue<TMemberDefinition> | PortableTextSpan<TBlockMarkDecorator>, TBlockStyle, TBlockListItem>, BlockRule>> & {
    lists?: ReadonlyArray<BlockListDefinition<TBlockListItem>>;
    marks?: Omit<BlockMarksDefinition, "annotations" | "decorators"> & {
        annotations?: TBlockMarkAnnotation[];
        decorators?: ReadonlyArray<BlockDecoratorDefinition<TBlockMarkDecorator>>;
    };
    of?: TupleOfLength<TMemberDefinition, 1>;
    styles?: ReadonlyArray<BlockStyleDefinition<TBlockStyle>>;
}>;
type ObjectValue<TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
}> = Simplify<{
    [Name in Extract<TFieldDefinition, {
        [required]?: false;
    }>["name"]]?: InferRawValue<Extract<TFieldDefinition, {
        name: Name;
    }>>;
} & {
    [Name in Extract<TFieldDefinition, {
        [required]?: true;
    }>["name"]]: InferRawValue<Extract<TFieldDefinition, {
        name: Name;
    }>>;
}>;
type ObjectDefinition<TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
}, TRequired extends boolean> = MergeOld<ObjectDefinition$1, DefinitionBase<TRequired, ObjectValue<TFieldDefinition>, RewriteValue<ObjectValue<TFieldDefinition>, ObjectRule>> & {
    fields: TFieldDefinition[];
}>;
interface SanityDocumentBase {
    _createdAt: string;
    _id: string;
    _rev: string;
    _type: "document";
    _updatedAt: string;
}
type SanityDocument<TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
} = never> = Simplify<ObjectValue<TFieldDefinition> & SanityDocumentBase>;
type AnySanityDocument = Merge<SanityDocument, {
    _type: string;
}>;
type DocumentRule<TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
}> = RuleDef<DocumentRule<TFieldDefinition>, SanityDocument<TFieldDefinition>>;
type DocumentDefinition<TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
}, TRequired extends boolean> = MergeOld<DocumentDefinition$1, DefinitionBase<TRequired, SanityDocument<TFieldDefinition>, DocumentRule<TFieldDefinition>> & {
    fields: TFieldDefinition[];
}>;
interface FileValueBase {
    _type: "file";
    asset: ReferenceValue<"sanity.fileAsset", false>;
}
type FileValue<TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
} = never> = Simplify<FileValueBase & ObjectValue<TFieldDefinition>>;
type FileDefinition<TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
}, TRequired extends boolean> = MergeOld<FileDefinition$1, DefinitionBase<TRequired, FileValue<TFieldDefinition>, RewriteValue<FileValue<TFieldDefinition>, FileRule>> & {
    fields?: TFieldDefinition[];
}>;
interface ImageValueBase {
    _type: "image";
    asset: ReferenceValue<"sanity.imageAsset", false>;
}
interface ImageValueExtra {
    crop: ImageCrop;
    hotspot: ImageHotspot;
}
type ImageValue<THotspot extends boolean = false, TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
} = never> = Simplify<ImageValueBase & ObjectValue<TFieldDefinition> & (THotspot extends true ? ImageValueExtra : unknown)>;
type ImageDefinition<THotspot extends boolean, TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
}, TRequired extends boolean> = MergeOld<ImageDefinition$1, DefinitionBase<TRequired, ImageValue<THotspot, TFieldDefinition>, RewriteValue<ImageValue<THotspot, TFieldDefinition>, ImageRule>> & {
    fields?: TFieldDefinition[];
    options?: MergeOld<ImageOptions, {
        hotspot?: THotspot;
    }>;
}>;
interface IntrinsicDefinitions<TNumberValue extends number, TStringValue extends string, TReferenced extends string, TReferenceWeak extends boolean, TBlockStyle extends string, TBlockListItem extends string, TBlockMarkDecorator extends string, TBlockMarkAnnotation extends DefinitionBase<any, any, any> & {
    name?: string;
}, THotspot extends boolean, TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
}, TMemberDefinition extends DefinitionBase<any, any, any> & {
    name?: string;
}, TRequired extends boolean> {
    array: ArrayDefinition<TMemberDefinition, TRequired>;
    block: BlockDefinition<TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, TMemberDefinition, TRequired>;
    boolean: BooleanDefinition<TRequired>;
    crossDatasetReference: CrossDatasetReferenceDefinition<TRequired>;
    date: DateDefinition<TRequired>;
    datetime: DatetimeDefinition<TRequired>;
    document: DocumentDefinition<TFieldDefinition, TRequired>;
    email: EmailDefinition<TRequired>;
    file: FileDefinition<TFieldDefinition, TRequired>;
    geopoint: GeopointDefinition<TRequired>;
    image: ImageDefinition<THotspot, TFieldDefinition, TRequired>;
    number: NumberDefinition<TNumberValue, TRequired>;
    object: ObjectDefinition<TFieldDefinition, TRequired>;
    reference: ReferenceDefinition<TReferenced, TReferenceWeak, TRequired>;
    slug: SlugDefinition<TRequired>;
    string: StringDefinition<TStringValue, TRequired>;
    text: TextDefinition<TRequired>;
    url: UrlDefinition<TRequired>;
}
type IntrinsicTypeName = Simplify<keyof IntrinsicDefinitions<any, any, any, any, any, any, any, any, any, any, any, any>>;
declare const aliasedType: unique symbol;
interface AliasValue<TType extends string> {
    [aliasedType]: TType;
}
type TypeAliasDefinition<TType extends string, TAlias extends IntrinsicTypeName, TNumberValue extends number, TStringValue extends string, TReferenced extends string, TReferenceWeak extends boolean, TBlockStyle extends string, TBlockListItem extends string, TBlockMarkDecorator extends string, TBlockMarkAnnotation extends DefinitionBase<any, any, any> & {
    name?: string;
}, THotspot extends boolean, TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
}, TMemberDefinition extends DefinitionBase<any, any, any> & {
    name?: string;
}, TRequired extends boolean> = MergeOld<TypeAliasDefinition$1<TType, TAlias>, DefinitionBase<TRequired, AliasValue<TType>, any> & {
    options?: TAlias extends IntrinsicTypeName ? IntrinsicDefinitions<TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, TRequired>[TAlias]["options"] : unknown;
}>;
declare const type: unique symbol;
type ArrayMemberDefinition<TType extends string, TName extends string, TAlias extends IntrinsicTypeName, TStrict extends StrictDefinition, TNumberValue extends number, TStringValue extends string, TReferenced extends string, TReferenceWeak extends boolean, TBlockStyle extends string, TBlockListItem extends string, TBlockMarkDecorator extends string, TBlockMarkAnnotation extends DefinitionBase<any, any, any> & {
    name?: string;
}, THotspot extends boolean, TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
}, TMemberDefinition extends DefinitionBase<any, any, any> & {
    name?: string;
}, AllowArrays extends boolean> = MaybeAllowUnknownProps<TStrict> & ((TType extends "array" ? AllowArrays : true) extends false ? never : TType extends IntrinsicTypeName ? Extract<{
    [type in IntrinsicTypeName]: Omit<IntrinsicDefinitions<TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, any>[type] extends DefinitionBase<any, infer Value, infer Rule> ? MergeOld<IntrinsicDefinitions<TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, any>[type], DefinitionBase<any, IsPlainObject<Value> extends false ? Value : IsStringLiteral<TName> extends false ? Value : Omit<Value, "_type"> & {
        _type: TName;
    }, RewriteValue<IsPlainObject<Value> extends false ? Value : IsStringLiteral<TName> extends false ? Value : Omit<Value, "_type"> & {
        _type: TName;
    }, Rule>>> : IntrinsicDefinitions<TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, any>[type], "name">;
}[IntrinsicTypeName], {
    type: TType;
}> : Omit<MergeOld<TypeAliasDefinition<TType, TAlias, TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, any>, DefinitionBase<any, AliasValue<TType> & (IsStringLiteral<TName> extends false ? unknown : {
    _type: TName;
}), any>>, "name">) & (IsStringLiteral<TName> extends false ? unknown : {
    name: TName;
}) & {
    name?: TName;
    [type]?: "arrayMember";
    type: TType;
};
declare const makeDefineArrayMember: <const AllowArrays extends boolean>() => <const TType extends string, const TName extends string, const TAlias extends IntrinsicTypeName, const TStrict extends StrictDefinition, const TNumberValue extends number, const TStringValue extends string, const TReferenced extends string, const TReferenceWeak extends boolean = false, const TBlockStyle extends string = BlockStyleDefault, const TBlockListItem extends string = BlockListItemDefault, const TBlockMarkDecorator extends string = BlockMarkDecoratorDefault, const TBlockMarkAnnotation extends DefinitionBase<any, any, any> & {
    name?: string;
} = never, const THotspot extends boolean = false, const TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
} = never, const TMemberDefinition extends DefinitionBase<any, any, any> & {
    name?: string;
} = never>(arrayOfSchema: ArrayMemberDefinition<TType, TName, TAlias, TStrict, TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, AllowArrays>, defineOptions?: DefineSchemaOptions<TStrict, TAlias>) => typeof arrayOfSchema;
declare const defineArrayMember: <const TType extends string, const TName extends string, const TAlias extends IntrinsicTypeName, const TStrict extends StrictDefinition, const TNumberValue extends number, const TStringValue extends string, const TReferenced extends string, const TReferenceWeak extends boolean = false, const TBlockStyle extends string = BlockStyleDefault, const TBlockListItem extends string = BlockListItemDefault, const TBlockMarkDecorator extends string = BlockMarkDecoratorDefault, const TBlockMarkAnnotation extends DefinitionBase<any, any, any> & {
    name?: string;
} = never, const THotspot extends boolean = false, const TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
} = never, const TMemberDefinition extends DefinitionBase<any, any, any> & {
    name?: string;
} = never>(arrayOfSchema: ArrayMemberDefinition<TType, TName, TAlias, TStrict, TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, false>, defineOptions?: DefineSchemaOptions<TStrict, TAlias> | undefined) => ArrayMemberDefinition<TType, TName, TAlias, TStrict, TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, false>;
type FieldDefinition<TType extends string, TName extends string, TAlias extends IntrinsicTypeName, TStrict extends StrictDefinition, TNumberValue extends number, TStringValue extends string, TReferenced extends string, TReferenceWeak extends boolean, TBlockStyle extends string, TBlockListItem extends string, TBlockMarkDecorator extends string, TBlockMarkAnnotation extends DefinitionBase<any, any, any> & {
    name?: string;
}, THotspot extends boolean, TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
}, TMemberDefinition extends DefinitionBase<any, any, any> & {
    name?: string;
}, TRequired extends boolean> = FieldDefinitionBase & MaybeAllowUnknownProps<TStrict> & (TType extends "block" ? never : TType extends IntrinsicTypeName ? Extract<{
    [type in IntrinsicTypeName]: Omit<IntrinsicDefinitions<TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, TRequired>[type], "TODO why does this fail without the omit? we're clearly not using it">;
}[IntrinsicTypeName], {
    type: TType;
}> : Omit<TypeAliasDefinition<TType, TAlias, TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, TRequired>, "TODO why does this fail without the omit? we're clearly not using it">) & {
    name: TName;
    [required]?: TRequired;
    [type]?: "field";
    type: TType;
};
declare const defineField: <const TType extends string, const TName extends string, const TAlias extends IntrinsicTypeName, const TStrict extends StrictDefinition, const TNumberValue extends number, const TStringValue extends string, const TReferenced extends string, const TReferenceWeak extends boolean = false, const TBlockStyle extends string = BlockStyleDefault, const TBlockListItem extends string = BlockListItemDefault, const TBlockMarkDecorator extends string = BlockMarkDecoratorDefault, const TBlockMarkAnnotation extends DefinitionBase<any, any, any> & {
    name?: string;
} = never, const THotspot extends boolean = false, const TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
} = never, const TMemberDefinition extends DefinitionBase<any, any, any> & {
    name?: string;
} = never, const TRequired extends boolean = false>(schemaField: FieldDefinition<TType, TName, TAlias, TStrict, TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, TRequired>, defineOptions?: DefineSchemaOptions<TStrict, TAlias>) => typeof schemaField;
type TypeDefinition<TType extends string, TName extends string, TAlias extends IntrinsicTypeName, TStrict extends StrictDefinition, TNumberValue extends number, TStringValue extends string, TReferenced extends string, TReferenceWeak extends boolean, TBlockStyle extends string, TBlockListItem extends string, TBlockMarkDecorator extends string, TBlockMarkAnnotation extends DefinitionBase<any, any, any> & {
    name?: string;
}, THotspot extends boolean, TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
}, TMemberDefinition extends DefinitionBase<any, any, any> & {
    name?: string;
}> = MaybeAllowUnknownProps<TStrict> & (TType extends IntrinsicTypeName ? Extract<{
    [type in IntrinsicTypeName]: Omit<IntrinsicDefinitions<TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, any>[type], "TODO why does this fail without the omit? we're clearly not using it">;
}[IntrinsicTypeName], {
    type: TType;
}> : TypeAliasDefinition<TType, TAlias, TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition, any>) & {
    name: TName;
    [type]?: "type";
    type: TType;
};
declare const defineType: <const TType extends string, const TName extends string, const TAlias extends IntrinsicTypeName, const TStrict extends StrictDefinition, const TNumberValue extends number, const TStringValue extends string, const TReferenced extends string, const TReferenceWeak extends boolean = false, const TBlockStyle extends string = BlockStyleDefault, const TBlockListItem extends string = BlockListItemDefault, const TBlockMarkDecorator extends string = BlockMarkDecoratorDefault, const TBlockMarkAnnotation extends DefinitionBase<any, any, any> & {
    name?: string;
} = never, const THotspot extends boolean = false, const TFieldDefinition extends DefinitionBase<any, any, any> & {
    name: string;
    [required]?: boolean;
} = never, const TMemberDefinition extends DefinitionBase<any, any, any> & {
    name?: string;
} = never>(schemaDefinition: TypeDefinition<TType, TName, TAlias, TStrict, TNumberValue, TStringValue, TReferenced, TReferenceWeak, TBlockStyle, TBlockListItem, TBlockMarkDecorator, TBlockMarkAnnotation, THotspot, TFieldDefinition, TMemberDefinition>, defineOptions?: DefineSchemaOptions<TStrict, TAlias>) => typeof schemaDefinition;
interface ConfigBase<TTypeDefinition extends TypeDefinition<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>, TPluginOptions extends PluginOptions<any, any>> {
    plugins?: (PluginOptions$1 | TPluginOptions)[];
    schema?: MergeOld<SchemaPluginOptions, {
        types?: TTypeDefinition[] | (TTypeDefinition extends never ? never : ComposableOption<TTypeDefinition[], Omit<ConfigContext, "client" | "currentUser" | "getClient" | "schema">>);
    }>;
}
type PluginOptions<TTypeDefinition extends TypeDefinition<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>, TPluginOptions extends PluginOptions<any, any>> = ConfigBase<TTypeDefinition, TPluginOptions> & Omit<PluginOptions$1, "beta" | "plugins" | "schema"> & {
    beta?: BetaFeatures;
};
declare const definePlugin: <TTypeDefinition extends TypeDefinition<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>, TPluginOptions extends PluginOptions<any, any>, TOptions = void>(arg: PluginOptions<TTypeDefinition, TPluginOptions> | ((options: TOptions) => PluginOptions<TTypeDefinition, TPluginOptions>)) => (options: TOptions) => PluginOptions<TTypeDefinition, TPluginOptions>;
type WorkspaceOptions<TTypeDefinition extends TypeDefinition<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>, TPluginOptions extends PluginOptions<any, any>> = MergeOld<Omit<WorkspaceOptions$1, "beta">, ConfigBase<TTypeDefinition, TPluginOptions> & {
    beta?: BetaFeatures;
    scheduledPublishing?: ScheduledPublishingPluginOptions;
}>;
type Config<TTypeDefinition extends TypeDefinition<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>, TPluginOptions extends PluginOptions<any, any>> = WorkspaceOptions<TTypeDefinition, TPluginOptions>[] | (Omit<WorkspaceOptions<TTypeDefinition, TPluginOptions>, "basePath" | "name"> & {
    basePath?: string;
    name?: string;
});
declare const defineConfig: <TTypeDefinition extends TypeDefinition<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>, TPluginOptions extends PluginOptions<any, any>>(config: Config<TTypeDefinition, TPluginOptions>) => typeof config extends any[] ? Extract<typeof config, any[]> : Exclude<typeof config, any[]>;
type FileAsset = OmitIndexSignature<FileAsset$1>;
type ImageAsset = MergeOld<OmitIndexSignature<ImageAsset$1>, {
    metadata: MergeOld<ImageAsset$1["metadata"], {
        exif?: {
            [key: string]: unknown;
            _type: "sanity.imageExifMetadata";
        };
        location?: GeopointValue;
    }>;
}>;
type ImplicitDocuments = {
    [TImplicitDoc in FileAsset | ImageAsset as TImplicitDoc["_type"]]: TImplicitDoc;
};
type ExpandAliasValues<Value, AliasedValues extends {
    [name: string]: any;
}> = Value extends AliasValue<infer TType> ? AliasedValues[TType] extends never ? unknown : IsPlainObject<ExpandAliasValues<AliasedValues[TType], AliasedValues>> extends false ? ExpandAliasValues<AliasedValues[TType], AliasedValues> : Omit<ExpandAliasValues<AliasedValues[TType], AliasedValues>, "_type"> & {
    _type: Value extends {
        _type: infer TOverwriteType;
    } ? TOverwriteType : TType;
} : Value extends (infer Item)[] ? (Item extends never ? never : IsPlainObject<Item> extends false ? ExpandAliasValues<Item, AliasedValues> : ExpandAliasValues<Item, AliasedValues> & {
    _key: string;
})[] : Value extends object ? {
    [key in keyof Value]: ExpandAliasValues<Value[key], AliasedValues>;
} : Value;
type InferSchemaValues<TConfig extends MaybeArray<ConfigBase<any, any>>> = PluginOptions$1 extends TConfig ? object : TConfig extends MaybeArray<ConfigBase<infer TTypeDefinition, infer TPluginOptions>> ? Merge<ImplicitDocuments, {
    [TName in TTypeDefinition["name"]]: ExpandAliasValues<AliasValue<TName>, InferSchemaValues<TPluginOptions> & {
        [TDefinition in TypeDefinition<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any> extends TTypeDefinition ? never : TTypeDefinition as TDefinition["name"]]: InferRawValue<TDefinition>;
    }>;
}> : never;
type DocumentValues<SanityValues extends InferSchemaValues<any>> = Extract<SanityValues[keyof SanityValues], AnySanityDocument>;
declare const castToTyped: <Untyped>(untyped: Untyped) => Untyped extends ReturnType<typeof defineArrayMember$1<infer TType extends string, infer TName extends string, any, any, infer TAlias extends IntrinsicTypeName | undefined, infer TStrict extends StrictDefinition>> | ReturnType<typeof defineField$1<infer TType extends string, infer TName extends string, any, any, infer TAlias extends IntrinsicTypeName | undefined, infer TStrict extends StrictDefinition>> | ReturnType<typeof defineType$1<infer TType extends string, infer TName extends string, any, any, infer TAlias extends IntrinsicTypeName | undefined, infer TStrict extends StrictDefinition>> ? (Untyped extends ReturnType<typeof defineArrayMember$1<TType, TName, any, any, TAlias, TStrict>> ? ArrayMemberDefinition<TType, TName, NonNullable<TAlias>, TStrict, any, any, any, any, any, any, any, any, any, any, any, any> : never) | (Untyped extends ReturnType<typeof defineField$1<TType, TName, any, any, TAlias, TStrict>> ? FieldDefinition<TType, TName, NonNullable<TAlias>, TStrict, any, any, any, any, any, any, any, any, any, any, any, any> : never) | (Untyped extends ReturnType<typeof defineType$1<TType, TName, any, any, TAlias, TStrict>> ? TypeDefinition<TType, TName, NonNullable<TAlias>, TStrict, any, any, any, any, any, any, any, any, any, any, any> : never) : Untyped extends Plugin<infer TOptions> ? ReturnType<typeof definePlugin<any, any, TOptions>> : {
    [README]: "\u26D4\uFE0F This can't be casted! Did you pass it the return value of a `define*` method from `sanity`?. \u26D4\uFE0F";
};
declare const castFromTyped: <Typed>(typed: Typed) => Typed extends TypeDefinition<infer TType extends string, infer TName extends string, infer TAlias extends IntrinsicTypeName, infer TStrict extends StrictDefinition, any, any, any, any, any, any, any, any, any, any, any> ? ReturnType<typeof defineType$1<TType, TName, {
    [key: string]: string;
}, {
    [key: string]: any;
}, TAlias, TStrict>> : Typed extends ArrayMemberDefinition<infer TType extends string, infer TName_1 extends string, infer TAlias_1 extends IntrinsicTypeName, infer TStrict_1 extends StrictDefinition, any, any, any, any, any, any, any, any, any, any, any, any> ? ReturnType<typeof defineArrayMember$1<TType, TName_1, {
    [key: string]: string;
}, { [key in never]: any; }, TAlias_1, TStrict_1>> : Typed extends FieldDefinition<infer TType extends string, infer TName_2 extends string, infer TAlias_2 extends IntrinsicTypeName, infer TStrict_2 extends StrictDefinition, any, any, any, any, any, any, any, any, any, any, any, any> ? ReturnType<typeof defineField$1<TType, TName_2, {
    [key: string]: string;
}, { [key in never]: any; }, TAlias_2, TStrict_2>> : Typed extends (options: infer TOptions) => PluginOptions<any, any> ? Plugin<TOptions> : {
    [README]: "\u26D4\uFE0F This can't be casted! Did you pass it the return value of a `define*` method from `sanity`?. \u26D4\uFE0F";
};

export { type AnySanityDocument, type ArrayDefinition, type ArrayMemberDefinition, type BlockDecoratorDefinition, type BlockDefinition, type BlockListDefinition, type BlockStyleDefinition, type BooleanDefinition, type Config, type ConfigBase, type CrossDatasetReferenceDefinition, type CrossDatasetReferenceValue, type DateDefinition, type DatetimeDefinition, type DefinitionBase, type DocumentDefinition, type DocumentRule, type DocumentValues, type EmailDefinition, type FieldDefinition, type FileAsset, type FileDefinition, type FileValue, type GeopointDefinition, type GetOriginalRule, type ImageAsset, type ImageDefinition, type ImageValue, type ImplicitDocuments, type InferSchemaValues, type IntrinsicTypeName, type MaybeTitledListValue, type NumberDefinition, type ObjectDefinition, type PluginOptions, type ReferenceDefinition, type ReferenceValue, type RegexRule, type SanityDocument, type SlugDefinition, type SlugValue, type StringDefinition, type TextDefinition, type TitledListValue, type TypeAliasDefinition, type TypeDefinition, type UrlDefinition, castFromTyped, castToTyped, defineArrayMember, defineConfig, defineField, definePlugin, defineType, makeDefineArrayMember, referenced };