import {CustomValidator} from 'sanity'
import merge from 'deepmerge'
import {PortableTextBlock} from 'sanity'
import {PreviewConfig} from 'sanity'
import {Rule as RuleType} from 'sanity'
import type * as S from 'sanity'
import {SchemaValidationValue} from 'sanity'
import {SlugOptions} from 'sanity'

/**
 * Apply `FieldProps` to fields.
 * This function merges the provided `FieldProps` into each field in the array.
 *
 * @param props - `FieldProps` to apply to fields.
 * @param fields - Array of fields to apply props to.
 * @returns A new array of fields with merged properties.
 */
declare const apply: (props: Partial<FieldProps>, fields: FieldReturn[]) => FieldReturn[]

declare const array: (props: ArrayField, mergeProps?: Partial<ArrayField>) => FieldReturn

export declare type ArrayField = SchemaToolField<S.ArrayDefinition>

export declare type BaseOmittedKeys = 'type' | 'name'

declare const block: (props?: BlockField, mergeProps?: Partial<BlockField>) => FieldReturn

declare const blockContent: (
  props?: BlockContentField,
  mergeProps?: Partial<BlockContentField>,
) => FieldReturn

export declare type BlockContentField = Partial<ArrayField>

export declare type BlockField = SchemaToolField<S.BlockDefinition>

declare const boolean: (props?: BooleanField, mergeProps?: Partial<BooleanField>) => FieldReturn

export declare type BooleanField = SchemaToolField<S.BooleanDefinition>

declare const categories: (
  _types: string | string[],
  props?: CategoriesField,
  mergeProps?: Partial<CategoriesField>,
) => FieldReturn

export declare type CategoriesField = MultiReferenceField & {
  options?: {
    types?: string[]
  }
}

declare const category: (
  types: string | string[],
  props?: CategoryField,
  mergeProps?: Partial<CategoryField>,
) => FieldReturn

export declare type CategoryField = ReferenceField

declare const checkbox: (props?: CheckboxField, mergeProps?: Partial<CheckboxField>) => FieldReturn

export declare type CheckboxField = BooleanField

export declare interface CofigurableFieldTypes {
  array: ArrayField
  block: BlockField
  blockContent: BlockContentField
  boolean: BooleanField
  categories: CategoriesField
  category: CategoryField
  checkbox: CheckboxField
  contentGroup: ContentGroupField
  date: DateField
  datetime: DatetimeField
  document: DocumentField
  email: EmailField
  excerpt: ExcerptField
  file: FileField
  formField: FormField
  geopoint: GeopointField
  hero: HeroField
  image: ImageField
  link: LinkField
  media: MediaField
  message: MessageField
  multiReference: MultiReferenceField
  number: NumberField
  object: ObjectField
  publishedDate: PublishedDateField
  radio: RadioField
  reference: ReferenceField
  seo: SeoField
  slug: SlugField
  string: StringField
  text: TextField
  title: TitleField
  url: UrlField
}

export declare type ConditionsType = {
  [key: string]: string | FieldProps[]
}

export declare type ConfigType = {
  [K in keyof CofigurableFieldTypes]?: Partial<CofigurableFieldTypes[K]>
}

declare const content: () => GroupReturn

declare const contentGroup: (
  props?: ContentGroupField,
  mergeProps?: Partial<ContentGroupField>,
) => FieldReturn[]

declare const contentGroup_2: ({select, prepare}?: PreviewConfig) => PreviewReturn

export declare type ContentGroupField = {
  label?: ToggleProp<StringField>
  heading?: ToggleProp<StringField>
  content?: ToggleProp<BlockContentField>
  link?: ToggleProp<LinkField>
}

export declare type CustomFieldsetType = (...args: any[]) => FieldsetReturn | FieldsetReturn[]

export declare type CustomFieldType = (...args: any[]) => FieldReturn | FieldReturn[]

export declare type CustomGroupType = (...args: any[]) => GroupReturn | GroupReturn[]

export declare type CustomPreviewType = (...args: any[]) => PreviewReturn

export declare interface CustomTypes {
  F?: {
    [key: string]: CustomFieldType
  }
  FS?: {
    [key: string]: CustomFieldsetType
  }
  G?: {
    [key: string]: CustomGroupType
  }
  P?: {
    [key: string]: CustomPreviewType
  }
  V?: {
    [key: string]: any
  }
}

export {CustomValidator}

declare const date: (props?: DateField, mergeProps?: Partial<DateField>) => FieldReturn

export declare type DateField = SchemaToolField<S.DateDefinition>

declare const datetime: (props?: DatetimeField, mergeProps?: Partial<DatetimeField>) => FieldReturn

export declare type DatetimeField = SchemaToolField<S.DatetimeDefinition>

declare const defaultPreview: (props?: {}) => PreviewReturn

declare const define: (
  name: string,
  props?: FieldsetProps,
  mergeProps?: FieldsetProps,
) => FieldsetReturn

declare const define_2: (name: string, props?: GroupProps, mergeProps?: GroupProps) => GroupReturn

declare const document_2: (props: DocumentField, mergeProps?: Partial<DocumentField>) => FieldReturn

export declare type DocumentField = SchemaToolField<S.DocumentDefinition>

declare const dropdown: (
  optionList: RadioList,
  props?: RadioField,
  mergeProps?: Partial<RadioField>,
) => FieldReturn

declare const email: (props?: EmailField, mergeProps?: Partial<EmailField>) => FieldReturn

export declare type EmailField = SchemaToolField<S.EmailDefinition>

declare const excerpt: (props?: ExcerptField, mergeProps?: Partial<ExcerptField>) => FieldReturn

export declare type ExcerptField = TextField

declare namespace F {
  export {
    blockContent,
    categories,
    category,
    checkbox,
    contentGroup,
    dropdown,
    excerpt,
    formField,
    link,
    hero,
    media,
    message,
    multiReference,
    publishedDate,
    radio,
    seo,
    title,
    array,
    block,
    boolean,
    date,
    datetime,
    document_2 as document,
    email,
    file,
    geopoint,
    image,
    number,
    object,
    reference,
    slug,
    string,
    text,
    url,
    getFieldName,
    getFieldTitle,
    getValidation,
    field,
    fieldDefaults,
    apply,
  }
}
export {F}

declare const field: (type: string, props?: FieldProps) => FieldReturn

export declare type FieldDefaults = {
  fieldset?: string
  title?: TitleField
  slug?: SlugField
  path?: StringField
}

declare const fieldDefaults: ({fieldset, title, slug, path}?: FieldDefaults) => FieldReturn[]

export declare type FieldExtensions = {
  name?: string
  required?: boolean
}

declare const fieldGroupComponentOptions: () => GroupReturn[]

declare const fieldGroupDefaults: () => GroupReturn[]

export declare type FieldProps = IntrinsicDefinitionsUnion &
  FieldExtensions &
  S.FieldDefinitionBase & {
    validation?: S.SchemaValidationValue
  }

export declare type FieldReturn = ReturnType<typeof S.defineField>

declare const fieldset: (name: string, fields: FieldReturn[]) => FieldReturn[]

declare const fieldsetDefaults: () => FieldsetReturn[]

export declare type FieldsetProps = Omit<S.FieldsetDefinition, 'name'> & {
  collapsible?: boolean
  collapsed?: boolean
}

export declare type FieldsetReturn = S.FieldsetDefinition

declare const file: (props?: FileField, mergeProps?: Partial<FileField>) => FieldReturn

export declare type FileField = SchemaToolField<S.FileDefinition>

export declare type FormField = Partial<ObjectField>

declare const formField: (props: FormField, mergeProps?: Partial<FormField>) => FieldReturn

declare namespace FS {
  export {fieldsetDefaults, seo_2 as seo, define, fieldset}
}
export {FS}

declare namespace G {
  export {
    fieldGroupDefaults,
    fieldGroupComponentOptions,
    content,
    meta,
    options,
    define_2 as define,
    group,
  }
}
export {G}

declare const geopoint: (props?: GeopointField, mergeProps?: Partial<GeopointField>) => FieldReturn

export declare type GeopointField = SchemaToolField<S.GeopointDefinition>

export declare const getConfig: (key?: string | undefined) => any

declare const getFieldName: (type: string, field?: FieldProps) => string

declare const getFieldTitle: (type: string, field?: FieldProps) => string

declare const getValidation: ({validation, required: isRequired}?: FieldProps) =>
  | false
  | {
      validation:
        | false
        | RuleType
        | SchemaValidationValue[]
        | ((rule: RuleType) => SchemaValidationValue)
        | undefined
    }
  | undefined

declare const group: (name: string, fields?: FieldReturn[]) => FieldReturn[]

export declare type GroupProps = Omit<S.FieldGroupDefinition, 'name'>

export declare type GroupReturn = S.FieldGroupDefinition

declare const hero: (props?: HeroField, mergeProps?: Partial<HeroField>) => FieldReturn

export declare type HeroArgs = {
  label?: ToggleProp<StringField>
  heading?: ToggleProp<StringField>
  content?: ToggleProp<BlockContentField>
  link?: ToggleProp<LinkField>
  media?: ToggleProp<MediaField>
  align?: ToggleProp<RadioField>
}

export declare type HeroField = Partial<ObjectField> & {
  args?: HeroArgs
}

declare const image: (props?: ImageField, mergeProps?: Partial<ImageField>) => FieldReturn

export declare type ImageField = SchemaToolField<S.ImageDefinition>

export declare type IntrinsicDefinitionsUnion = Partial<
  S.IntrinsicDefinitions[keyof S.IntrinsicDefinitions]
>

declare const link: (props?: LinkField, mergeProps?: Partial<LinkField>) => FieldReturn

declare const link_2: ({prefix, select, prepare}?: LinkPreviewProps) => PreviewReturn

export declare type LinkArgs = {
  condition?: RadioField
  url?: ToggleProp<StringField>
  page?: ToggleProp<ReferenceField>
  hasHash?: ToggleProp<CheckboxField>
  hash?: ToggleProp<StringField>
  file?: ToggleProp<FileField>
  video?: ToggleProp<FileField>
  label?: ToggleProp<StringField>
  linkStyle?: ToggleProp<RadioField>
  linkSize?: ToggleProp<RadioField>
  target?: ToggleProp<CheckboxField>
}

export declare type LinkField = Partial<ObjectField> & {
  types?: string[]
  args?: LinkArgs
  groups?: S.FieldGroupDefinition[]
  conditions?: ConditionsType
}

export declare type LinkPreviewProps = S.PreviewConfig & {
  prefix?: string
}

declare const media: (props?: MediaField, mergeProps?: Partial<MediaField>) => FieldReturn

export declare type MediaArgs = {
  image?: ToggleProp<ImageField>
  video?: ToggleProp<FileField>
  caption?: ToggleProp<StringField>
  ratio?: ToggleProp<StringField>
}

export declare type MediaField = Partial<ObjectField> & {
  args?: MediaArgs
  conditions?: ConditionsType
}

export {merge}

declare const message: (
  _message: string,
  props?: MessageField,
  mergeProps?: Partial<MessageField>,
) => FieldReturn

export declare type MessageField = StringField & {
  options?: {
    message?: string
  }
}

declare const meta: () => GroupReturn

declare const multiReference: (
  types: string | string[],
  props?: MultiReferenceField,
  mergeProps?: Partial<MultiReferenceField>,
) => FieldReturn

export declare type MultiReferenceField = Partial<ArrayField> & {
  options?: {
    types?: string[]
  }
}

declare const number: (props?: NumberField, mergeProps?: Partial<NumberField>) => FieldReturn

export declare type NumberField = SchemaToolField<S.NumberDefinition>

declare const object: (props: ObjectField, mergeProps?: Partial<ObjectField>) => FieldReturn

export declare type ObjectField = SchemaToolField<S.ObjectDefinition>

declare const options: () => GroupReturn

declare namespace P {
  export {
    defaultPreview,
    titleImage,
    contentGroup_2 as contentGroup,
    link_2 as link,
    preview,
    richText,
    text_2 as text,
  }
}
export {P}

export {PortableTextBlock}

declare const preview: ({title, media, prepare, ...props}?: PreviewProps) => PreviewReturn

export {PreviewConfig}

export declare type PreviewPrepare = Pick<S.PreviewConfig, 'prepare'>

export declare type PreviewProps = PreviewPrepare & {
  title?: string
  media?: string
  [key: string]: string | undefined | PreviewPrepare['prepare']
}

export declare type PreviewReturn = S.PreviewConfig

declare const publishedDate: (
  props?: PublishedDateField,
  mergeProps?: Partial<PublishedDateField>,
) => FieldReturn

export declare type PublishedDateField = DateField

declare const radio: (
  optionList: RadioList,
  props?: RadioField,
  mergeProps?: Partial<RadioField>,
) => FieldReturn

export declare type RadioField = StringField

export declare type RadioList = S.StringOptions['list']

declare const reference: (
  types: string[] | string,
  props?: ReferenceField,
  mergeProps?: Partial<ReferenceField>,
) => FieldReturn

export declare type ReferenceField = SchemaToolField<Omit<S.ReferenceDefinition, 'to'>>

declare const required: (Rule: RuleType) => SchemaValidationValue

declare const richText: (content: PortableTextBlock[]) => string

export {RuleType}

declare const schemaBuilder: {
  F: typeof F
  FS: typeof FS
  G: typeof G
  P: typeof P
  V: typeof V
}
export default schemaBuilder

export declare type SchemaToolField<T> = Omit<T, BaseOmittedKeys | 'validation'> &
  FieldExtensions &
  S.FieldDefinitionBase & {
    validation?: S.SchemaValidationValue
  }

export {SchemaValidationValue}

declare const seo: (props?: SeoField, mergeProps?: Partial<SeoField>) => FieldReturn

declare const seo_2: () => FieldsetReturn

export declare type SeoField = Omit<ObjectField, 'fields'>

export declare const setConfig: (config: any) => void

declare const slug: (props?: SlugField, mergeProps?: Partial<SlugField>) => FieldReturn

export declare type SlugField = SchemaToolField<S.SlugDefinition>

export {SlugOptions}

declare const string: (props?: StringField, mergeProps?: Partial<StringField>) => FieldReturn

export declare type StringField = SchemaToolField<S.StringDefinition>

declare const text: (props?: TextField, mergeProps?: Partial<TextField>) => FieldReturn

declare const text_2: (title: string) => PreviewPrepare

export declare type TextField = SchemaToolField<S.TextDefinition>

declare const title: (props?: TitleField, mergeProps?: Partial<TitleField>) => FieldReturn

export declare type TitleField = StringField

declare const titleImage: (props?: {}) => PreviewReturn

export declare type ToggleProp<T> = T | false

declare const url: (props?: UrlField, mergeProps?: Partial<UrlField>) => FieldReturn

export declare type UrlField = SchemaToolField<S.UrlDefinition>

declare namespace V {
  export {required, validation}
}
export {V}

declare const validation: (fn: CustomValidator) => (Rule: RuleType) => SchemaValidationValue

export declare type ValidationReturn = S.ValidationBuilder<S.RuleDef<any, any>, any>

export declare function withConfig<T extends CustomTypes>(
  config?: ConfigType,
  customTypes?: T,
): typeof schemaBuilder & T

export {}